package org.stragma.symbian.apply.stratego;

import org.strategoxt.stratego_lib.*;
import org.strategoxt.stratego_lib.*;
import org.strategoxt.lang.*;
import org.spoofax.interpreter.terms.*;
import static org.strategoxt.lang.Term.*;
import org.spoofax.interpreter.library.AbstractPrimitive;
import java.util.ArrayList;
import java.lang.ref.WeakReference;

@SuppressWarnings("all") public class Simplify  
{ 
  protected static final boolean TRACES_ENABLED = true;

  protected static ITermFactory constantFactory;

  private static WeakReference<Context> initedContext;

  private static boolean isIniting;

  protected static IStrategoTerm constStatements0;

  protected static IStrategoTerm const121;

  protected static IStrategoTerm const120;

  protected static IStrategoTerm const119;

  protected static IStrategoTerm constCons24;

  protected static IStrategoTerm constCons23;

  protected static IStrategoTerm constCons22;

  protected static IStrategoTerm constCons21;

  protected static IStrategoTerm constCons20;

  protected static IStrategoTerm constCons19;

  protected static IStrategoTerm constCons18;

  protected static IStrategoTerm constCons17;

  protected static IStrategoTerm const118;

  protected static IStrategoTerm const117;

  protected static IStrategoTerm const116;

  protected static IStrategoTerm const115;

  protected static IStrategoTerm const114;

  protected static IStrategoTerm const113;

  protected static IStrategoTerm const112;

  protected static IStrategoTerm const111;

  protected static IStrategoTerm const110;

  protected static IStrategoTerm const109;

  protected static IStrategoTerm const108;

  protected static IStrategoTerm constFalse0;

  protected static IStrategoTerm constInt3;

  protected static IStrategoTerm constInt2;

  protected static IStrategoTerm const107;

  protected static IStrategoTerm const106;

  protected static IStrategoTerm const105;

  protected static IStrategoTerm const104;

  protected static IStrategoTerm const103;

  protected static IStrategoTerm const102;

  protected static IStrategoTerm const101;

  protected static IStrategoTerm const100;

  protected static IStrategoTerm const99;

  protected static IStrategoTerm const98;

  protected static IStrategoTerm const97;

  protected static IStrategoTerm const96;

  protected static IStrategoTerm const95;

  protected static IStrategoTerm const94;

  protected static IStrategoTerm const93;

  protected static IStrategoTerm const92;

  protected static IStrategoTerm const91;

  protected static IStrategoTerm const90;

  protected static IStrategoTerm const89;

  protected static IStrategoTerm const88;

  protected static IStrategoTerm const87;

  protected static IStrategoTerm const86;

  protected static IStrategoTerm const85;

  protected static IStrategoTerm const84;

  protected static IStrategoTerm const83;

  protected static IStrategoTerm const82;

  protected static IStrategoTerm const81;

  protected static IStrategoTerm const80;

  protected static IStrategoTerm const79;

  protected static IStrategoTerm const78;

  protected static IStrategoTerm const77;

  protected static IStrategoTerm const76;

  protected static IStrategoTerm const75;

  protected static IStrategoTerm const74;

  protected static IStrategoTerm const73;

  protected static IStrategoTerm const72;

  protected static IStrategoTerm const71;

  protected static IStrategoTerm const70;

  protected static IStrategoTerm const69;

  protected static IStrategoTerm const68;

  protected static IStrategoTerm const67;

  protected static IStrategoTerm const66;

  protected static IStrategoTerm const65;

  protected static IStrategoTerm const64;

  protected static IStrategoTerm const63;

  protected static IStrategoTerm const62;

  protected static IStrategoTerm const61;

  protected static IStrategoTerm const60;

  protected static IStrategoTerm const59;

  protected static IStrategoTerm const58;

  protected static IStrategoTerm const57;

  protected static IStrategoTerm const56;

  protected static IStrategoTerm constInt1;

  protected static IStrategoTerm constCons16;

  protected static IStrategoTerm constDR_DUMMY0;

  protected static IStrategoTerm const55;

  protected static IStrategoTerm constInt0;

  protected static IStrategoTerm const54;

  protected static IStrategoTerm const53;

  protected static IStrategoTerm const52;

  protected static IStrategoTerm constCons15;

  protected static IStrategoTerm constCons14;

  protected static IStrategoTerm constCons13;

  protected static IStrategoTerm constCons12;

  protected static IStrategoTerm constCons11;

  protected static IStrategoTerm constCons10;

  protected static IStrategoTerm constCons9;

  protected static IStrategoTerm constCons8;

  protected static IStrategoTerm constCons7;

  protected static IStrategoTerm constCons6;

  protected static IStrategoTerm constCons5;

  protected static IStrategoTerm constCons4;

  protected static IStrategoTerm constCons3;

  protected static IStrategoTerm constCons2;

  protected static IStrategoTerm constCons1;

  protected static IStrategoTerm constCons0;

  protected static IStrategoTerm constNil0;

  protected static IStrategoTerm const51;

  protected static IStrategoTerm constNo_use_apply_assertions0;

  protected static IStrategoTerm const50;

  protected static IStrategoTerm constNo_use_program_assertions0;

  protected static IStrategoTerm const49;

  protected static IStrategoTerm constNo_generate_loop_assertions0;

  protected static IStrategoTerm const48;

  protected static IStrategoTerm constNo_generate_if_assertions0;

  protected static IStrategoTerm const47;

  protected static IStrategoTerm constNo_normalise_expressions0;

  protected static IStrategoTerm const46;

  protected static IStrategoTerm constNo_propagate_constant_assignments0;

  protected static IStrategoTerm const45;

  protected static IStrategoTerm constNo_evaluate_constant_expressions0;

  protected static IStrategoTerm const44;

  protected static IStrategoTerm const43;

  protected static IStrategoTerm constMerge_complex_multiply0;

  protected static IStrategoTerm const42;

  protected static IStrategoTerm const41;

  protected static IStrategoTerm constUse_apply_assertions0;

  protected static IStrategoTerm const40;

  protected static IStrategoTerm const39;

  protected static IStrategoTerm constUse_program_assertions0;

  protected static IStrategoTerm const38;

  protected static IStrategoTerm const37;

  protected static IStrategoTerm constGenerate_loop_assertions0;

  protected static IStrategoTerm const36;

  protected static IStrategoTerm const35;

  protected static IStrategoTerm constGenerate_if_assertions0;

  protected static IStrategoTerm const34;

  protected static IStrategoTerm const33;

  protected static IStrategoTerm constPropagate_constant_assignments0;

  protected static IStrategoTerm const32;

  protected static IStrategoTerm const31;

  protected static IStrategoTerm constNormalise_expressions0;

  protected static IStrategoTerm const30;

  protected static IStrategoTerm const29;

  protected static IStrategoTerm constEvaluate_constant_expressions0;

  protected static IStrategoTerm const28;

  protected static IStrategoTerm const27;

  protected static IStrategoTerm constOptimise_20;

  protected static IStrategoTerm const26;

  protected static IStrategoTerm const25;

  protected static IStrategoTerm constOptimise_10;

  protected static IStrategoTerm const24;

  protected static IStrategoTerm const23;

  protected static IStrategoTerm constOptimise_00;

  protected static IStrategoTerm const22;

  protected static IStrategoTerm const21;

  protected static IStrategoTerm constWidth_5120;

  protected static IStrategoTerm const20;

  protected static IStrategoTerm const19;

  protected static IStrategoTerm constLoop_nosingle0;

  protected static IStrategoTerm const18;

  protected static IStrategoTerm const17;

  protected static IStrategoTerm constLoop_raster0;

  protected static IStrategoTerm const16;

  protected static IStrategoTerm const15;

  protected static IStrategoTerm constLoop_block0;

  protected static IStrategoTerm const14;

  protected static IStrategoTerm const13;

  protected static IStrategoTerm constLoop_index0;

  protected static IStrategoTerm const12;

  protected static IStrategoTerm const11;

  protected static IStrategoTerm constLoop_noindex0;

  protected static IStrategoTerm const10;

  protected static IStrategoTerm const9;

  protected static IStrategoTerm constLoop_100;

  protected static IStrategoTerm const8;

  protected static IStrategoTerm const7;

  protected static IStrategoTerm constLoop_20;

  protected static IStrategoTerm const6;

  protected static IStrategoTerm const5;

  protected static IStrategoTerm constLoop_10;

  protected static IStrategoTerm const4;

  protected static IStrategoTerm const3;

  protected static IStrategoTerm constTest0;

  protected static IStrategoTerm const2;

  protected static IStrategoTerm const1;

  protected static IStrategoTerm constTrue0;

  protected static IStrategoTerm constSimple0;

  protected static IStrategoTerm const0;

  public static IStrategoConstructor _consConc_2;

  public static IStrategoConstructor _consNone_0;

  public static IStrategoConstructor _consSome_1;

  public static IStrategoConstructor _consTrue_0;

  public static IStrategoConstructor _consFalse_0;

  public static IStrategoConstructor _consNot_1;

  public static IStrategoConstructor _consInt_1;

  public static IStrategoConstructor _consMul_2;

  public static IStrategoConstructor _consDiv_2;

  public static IStrategoConstructor _consMod_2;

  public static IStrategoConstructor _consAdd_2;

  public static IStrategoConstructor _consSub_2;

  public static IStrategoConstructor _consNeg_1;

  public static IStrategoConstructor _consLt_2;

  public static IStrategoConstructor _consGt_2;

  public static IStrategoConstructor _consLeq_2;

  public static IStrategoConstructor _consGeq_2;

  public static IStrategoConstructor _consEqu_2;

  public static IStrategoConstructor _consNeq_2;

  public static IStrategoConstructor _consAnd_2;

  public static IStrategoConstructor _consOr_2;

  public static IStrategoConstructor _consIfKnownExp_3;

  public static IStrategoConstructor _consKnown_1;

  public static IStrategoConstructor _consIfElseExp_3;

  public static IStrategoConstructor _consCAssign_2;

  public static IStrategoConstructor _consVar_1;

  public static IStrategoConstructor _consProcedure_5;

  public static IStrategoConstructor _consDeclarations_1;

  public static IStrategoConstructor _consStatements_1;

  public static IStrategoConstructor _consAssign_2;

  public static IStrategoConstructor _consIf_2;

  public static IStrategoConstructor _consIfElse_3;

  public static IStrategoConstructor _consFor_4;

  public static IStrategoConstructor _consWhile_2;

  public static IStrategoConstructor _consAssert_1;

  public static IStrategoConstructor _consIfKnownStmt_3;

  public static IStrategoConstructor _consCFor_4;

  public static IStrategoConstructor _consStatement_1;

  public static IStrategoConstructor _consDR_DUMMY_0;

  public static IStrategoConstructor _consWidth_512_0;

  public static IStrategoConstructor _consLoop_nosingle_0;

  public static IStrategoConstructor _consLoop_noindex_0;

  public static IStrategoConstructor _consLoop_index_0;

  public static IStrategoConstructor _consLoop_raster_0;

  public static IStrategoConstructor _consLoop_block_0;

  public static IStrategoConstructor _consLoop_10_0;

  public static IStrategoConstructor _consLoop_2_0;

  public static IStrategoConstructor _consLoop_1_0;

  public static IStrategoConstructor _consTest_0;

  public static IStrategoConstructor _consSimple_0;

  public static IStrategoConstructor _consOptimise_0_0;

  public static IStrategoConstructor _consOptimise_1_0;

  public static IStrategoConstructor _consOptimise_2_0;

  public static IStrategoConstructor _consNo_use_apply_assertions_0;

  public static IStrategoConstructor _consNo_use_program_assertions_0;

  public static IStrategoConstructor _consNo_generate_loop_assertions_0;

  public static IStrategoConstructor _consNo_generate_if_assertions_0;

  public static IStrategoConstructor _consNo_normalise_expressions_0;

  public static IStrategoConstructor _consNo_propagate_constant_assignments_0;

  public static IStrategoConstructor _consNo_evaluate_constant_expressions_0;

  public static IStrategoConstructor _consMerge_complex_multiply_0;

  public static IStrategoConstructor _consUse_apply_assertions_0;

  public static IStrategoConstructor _consUse_program_assertions_0;

  public static IStrategoConstructor _consGenerate_loop_assertions_0;

  public static IStrategoConstructor _consGenerate_if_assertions_0;

  public static IStrategoConstructor _consNormalise_expressions_0;

  public static IStrategoConstructor _consPropagate_constant_assignments_0;

  public static IStrategoConstructor _consEvaluate_constant_expressions_0;

  public static Context init(Context context)
  { 
    synchronized(Simplify.class)
    { 
      if(isIniting)
        return null;
      try
      { 
        isIniting = true;
        ITermFactory termFactory = context.getFactory();
        if(constantFactory == null)
        { 
          initConstructors(termFactory);
          initConstants(termFactory);
        }
        if(initedContext == null || initedContext.get() != context)
        { 
          org.strategoxt.stratego_lib.Main.init(context);
          org.strategoxt.stratego_lib.Main.init(context);
          context.registerComponent("Simplify");
        }
        initedContext = new WeakReference<Context>(context);
        constantFactory = termFactory;
      }
      finally
      { 
        isIniting = false;
      }
      return context;
    }
  }

  public static Context init()
  { 
    return init(new Context());
  }

  public static void main(String args[])
  { 
    Context context = init();
    context.setStandAlone(true);
    try
    { 
      IStrategoTerm result;
      try
      { 
        result = context.invokeStrategyCLI(io_$Simplify_0_0.instance, "Simplify", args);
      }
      finally
      { 
        context.getIOAgent().closeAllFiles();
      }
      if(result == null)
      { 
        System.err.println("Simplify" + (TRACES_ENABLED ? ": rewriting failed, trace:" : ": rewriting failed"));
        context.printStackTrace();
        context.setStandAlone(false);
        System.exit(1);
      }
      else
      { 
        System.out.println(result);
        context.setStandAlone(false);
        System.exit(0);
      }
    }
    catch(StrategoExit exit)
    { 
      context.setStandAlone(false);
      System.exit(exit.getValue());
    }
  }

  public static IStrategoTerm mainNoExit(String ... args) throws StrategoExit
  { 
    return mainNoExit(new Context(), args);
  }

  public static IStrategoTerm mainNoExit(Context context, String ... args) throws StrategoExit
  { 
    try
    { 
      init(context);
      return context.invokeStrategyCLI(io_$Simplify_0_0.instance, "Simplify", args);
    }
    finally
    { 
      context.getIOAgent().closeAllFiles();
    }
  }

  public static Strategy getMainStrategy()
  { 
    return io_$Simplify_0_0.instance;
  }

  public static void initConstructors(ITermFactory termFactory)
  { 
    _consConc_2 = termFactory.makeConstructor("Conc", 2);
    _consNone_0 = termFactory.makeConstructor("None", 0);
    _consSome_1 = termFactory.makeConstructor("Some", 1);
    _consTrue_0 = termFactory.makeConstructor("True", 0);
    _consFalse_0 = termFactory.makeConstructor("False", 0);
    _consNot_1 = termFactory.makeConstructor("Not", 1);
    _consInt_1 = termFactory.makeConstructor("Int", 1);
    _consMul_2 = termFactory.makeConstructor("Mul", 2);
    _consDiv_2 = termFactory.makeConstructor("Div", 2);
    _consMod_2 = termFactory.makeConstructor("Mod", 2);
    _consAdd_2 = termFactory.makeConstructor("Add", 2);
    _consSub_2 = termFactory.makeConstructor("Sub", 2);
    _consNeg_1 = termFactory.makeConstructor("Neg", 1);
    _consLt_2 = termFactory.makeConstructor("Lt", 2);
    _consGt_2 = termFactory.makeConstructor("Gt", 2);
    _consLeq_2 = termFactory.makeConstructor("Leq", 2);
    _consGeq_2 = termFactory.makeConstructor("Geq", 2);
    _consEqu_2 = termFactory.makeConstructor("Equ", 2);
    _consNeq_2 = termFactory.makeConstructor("Neq", 2);
    _consAnd_2 = termFactory.makeConstructor("And", 2);
    _consOr_2 = termFactory.makeConstructor("Or", 2);
    _consIfKnownExp_3 = termFactory.makeConstructor("IfKnownExp", 3);
    _consKnown_1 = termFactory.makeConstructor("Known", 1);
    _consIfElseExp_3 = termFactory.makeConstructor("IfElseExp", 3);
    _consCAssign_2 = termFactory.makeConstructor("CAssign", 2);
    _consVar_1 = termFactory.makeConstructor("Var", 1);
    _consProcedure_5 = termFactory.makeConstructor("Procedure", 5);
    _consDeclarations_1 = termFactory.makeConstructor("Declarations", 1);
    _consStatements_1 = termFactory.makeConstructor("Statements", 1);
    _consAssign_2 = termFactory.makeConstructor("Assign", 2);
    _consIf_2 = termFactory.makeConstructor("If", 2);
    _consIfElse_3 = termFactory.makeConstructor("IfElse", 3);
    _consFor_4 = termFactory.makeConstructor("For", 4);
    _consWhile_2 = termFactory.makeConstructor("While", 2);
    _consAssert_1 = termFactory.makeConstructor("Assert", 1);
    _consIfKnownStmt_3 = termFactory.makeConstructor("IfKnownStmt", 3);
    _consCFor_4 = termFactory.makeConstructor("CFor", 4);
    _consStatement_1 = termFactory.makeConstructor("Statement", 1);
    _consDR_DUMMY_0 = termFactory.makeConstructor("DR_DUMMY", 0);
    _consWidth_512_0 = termFactory.makeConstructor("Width-512", 0);
    _consLoop_nosingle_0 = termFactory.makeConstructor("Loop-nosingle", 0);
    _consLoop_noindex_0 = termFactory.makeConstructor("Loop-noindex", 0);
    _consLoop_index_0 = termFactory.makeConstructor("Loop-index", 0);
    _consLoop_raster_0 = termFactory.makeConstructor("Loop-raster", 0);
    _consLoop_block_0 = termFactory.makeConstructor("Loop-block", 0);
    _consLoop_10_0 = termFactory.makeConstructor("Loop-10", 0);
    _consLoop_2_0 = termFactory.makeConstructor("Loop-2", 0);
    _consLoop_1_0 = termFactory.makeConstructor("Loop-1", 0);
    _consTest_0 = termFactory.makeConstructor("Test", 0);
    _consSimple_0 = termFactory.makeConstructor("Simple", 0);
    _consOptimise_0_0 = termFactory.makeConstructor("Optimise-0", 0);
    _consOptimise_1_0 = termFactory.makeConstructor("Optimise-1", 0);
    _consOptimise_2_0 = termFactory.makeConstructor("Optimise-2", 0);
    _consNo_use_apply_assertions_0 = termFactory.makeConstructor("No-use-apply-assertions", 0);
    _consNo_use_program_assertions_0 = termFactory.makeConstructor("No-use-program-assertions", 0);
    _consNo_generate_loop_assertions_0 = termFactory.makeConstructor("No-generate-loop-assertions", 0);
    _consNo_generate_if_assertions_0 = termFactory.makeConstructor("No-generate-if-assertions", 0);
    _consNo_normalise_expressions_0 = termFactory.makeConstructor("No-normalise-expressions", 0);
    _consNo_propagate_constant_assignments_0 = termFactory.makeConstructor("No-propagate-constant-assignments", 0);
    _consNo_evaluate_constant_expressions_0 = termFactory.makeConstructor("No-evaluate-constant-expressions", 0);
    _consMerge_complex_multiply_0 = termFactory.makeConstructor("Merge-complex-multiply", 0);
    _consUse_apply_assertions_0 = termFactory.makeConstructor("Use-apply-assertions", 0);
    _consUse_program_assertions_0 = termFactory.makeConstructor("Use-program-assertions", 0);
    _consGenerate_loop_assertions_0 = termFactory.makeConstructor("Generate-loop-assertions", 0);
    _consGenerate_if_assertions_0 = termFactory.makeConstructor("Generate-if-assertions", 0);
    _consNormalise_expressions_0 = termFactory.makeConstructor("Normalise-expressions", 0);
    _consPropagate_constant_assignments_0 = termFactory.makeConstructor("Propagate-constant-assignments", 0);
    _consEvaluate_constant_expressions_0 = termFactory.makeConstructor("Evaluate-constant-expressions", 0);
  }

  public static void initConstants(ITermFactory termFactory)
  { 
    const0 = termFactory.makeString("get-option: ");
    constSimple0 = termFactory.makeAppl(Simplify._consSimple_0, NO_TERMS);
    constTrue0 = termFactory.makeAppl(Simplify._consTrue_0, NO_TERMS);
    const1 = termFactory.makeTuple(Simplify.constSimple0, Simplify.constTrue0);
    const2 = termFactory.makeString("--Simple          Use a very simple structure, suitable for debugging and testing");
    constTest0 = termFactory.makeAppl(Simplify._consTest_0, NO_TERMS);
    const3 = termFactory.makeTuple(Simplify.constTest0, Simplify.constTrue0);
    const4 = termFactory.makeString("--test            Generate module <mod>_test to test other implementations");
    constLoop_10 = termFactory.makeAppl(Simplify._consLoop_1_0, NO_TERMS);
    const5 = termFactory.makeTuple(Simplify.constLoop_10, Simplify.constTrue0);
    const6 = termFactory.makeString("--loop-1          Use single-loop structure for apply loop");
    constLoop_20 = termFactory.makeAppl(Simplify._consLoop_2_0, NO_TERMS);
    const7 = termFactory.makeTuple(Simplify.constLoop_20, Simplify.constTrue0);
    const8 = termFactory.makeString("--loop-2          Use two loop structure for apply loop (default)");
    constLoop_100 = termFactory.makeAppl(Simplify._consLoop_10_0, NO_TERMS);
    const9 = termFactory.makeTuple(Simplify.constLoop_100, Simplify.constTrue0);
    const10 = termFactory.makeString("--loop-10         Use ten loop structure for apply loop");
    constLoop_noindex0 = termFactory.makeAppl(Simplify._consLoop_noindex_0, NO_TERMS);
    const11 = termFactory.makeTuple(Simplify.constLoop_noindex0, Simplify.constTrue0);
    const12 = termFactory.makeString("--loop-noindex    Do not use an index variable in the apply loop (default)");
    constLoop_index0 = termFactory.makeAppl(Simplify._consLoop_index_0, NO_TERMS);
    const13 = termFactory.makeTuple(Simplify.constLoop_index0, Simplify.constTrue0);
    const14 = termFactory.makeString("--loop-index      Use an index variable in the apply loop");
    constLoop_block0 = termFactory.makeAppl(Simplify._consLoop_block_0, NO_TERMS);
    const15 = termFactory.makeTuple(Simplify.constLoop_block0, Simplify.constTrue0);
    const16 = termFactory.makeString("--loop-block      Use a block-structured apply loop (default)");
    constLoop_raster0 = termFactory.makeAppl(Simplify._consLoop_raster_0, NO_TERMS);
    const17 = termFactory.makeTuple(Simplify.constLoop_raster0, Simplify.constTrue0);
    const18 = termFactory.makeString("--loop-raster     Use a raster-structured apply loop");
    constLoop_nosingle0 = termFactory.makeAppl(Simplify._consLoop_nosingle_0, NO_TERMS);
    const19 = termFactory.makeTuple(Simplify.constLoop_nosingle0, Simplify.constTrue0);
    const20 = termFactory.makeString("--loop-nosingle   Prevent compiling a single apply loop (default is single loop can be used)");
    constWidth_5120 = termFactory.makeAppl(Simplify._consWidth_512_0, NO_TERMS);
    const21 = termFactory.makeTuple(Simplify.constWidth_5120, Simplify.constTrue0);
    const22 = termFactory.makeString("--width-512       Handle fixed-width image specially (default no special cases)");
    constOptimise_00 = termFactory.makeAppl(Simplify._consOptimise_0_0, NO_TERMS);
    const23 = termFactory.makeTuple(Simplify.constOptimise_00, Simplify.constTrue0);
    const24 = termFactory.makeString("--optimise-0      Do not perform any optimisations");
    constOptimise_10 = termFactory.makeAppl(Simplify._consOptimise_1_0, NO_TERMS);
    const25 = termFactory.makeTuple(Simplify.constOptimise_10, Simplify.constTrue0);
    const26 = termFactory.makeString("--optimise-1      Perform optimisations marked (1) below");
    constOptimise_20 = termFactory.makeAppl(Simplify._consOptimise_2_0, NO_TERMS);
    const27 = termFactory.makeTuple(Simplify.constOptimise_20, Simplify.constTrue0);
    const28 = termFactory.makeString("--optimise-2      Perform optimisations marked (1) or (2) below\nEach of the following options has a --no-... form to negate it");
    constEvaluate_constant_expressions0 = termFactory.makeAppl(Simplify._consEvaluate_constant_expressions_0, NO_TERMS);
    const29 = termFactory.makeTuple(Simplify.constEvaluate_constant_expressions0, Simplify.constTrue0);
    const30 = termFactory.makeString("--evaluate-constant-expressions   (1) Evaluate expressions that contain constants to simplify the expressions");
    constNormalise_expressions0 = termFactory.makeAppl(Simplify._consNormalise_expressions_0, NO_TERMS);
    const31 = termFactory.makeTuple(Simplify.constNormalise_expressions0, Simplify.constTrue0);
    const32 = termFactory.makeString("--normalise-expressions           (1) Convert expressions to canonical form (rearranges and merges terms )");
    constPropagate_constant_assignments0 = termFactory.makeAppl(Simplify._consPropagate_constant_assignments_0, NO_TERMS);
    const33 = termFactory.makeTuple(Simplify.constPropagate_constant_assignments0, Simplify.constTrue0);
    const34 = termFactory.makeString("--propagate-constant-assignments  (2) Propagate values from constant-expression assignments");
    constGenerate_if_assertions0 = termFactory.makeAppl(Simplify._consGenerate_if_assertions_0, NO_TERMS);
    const35 = termFactory.makeTuple(Simplify.constGenerate_if_assertions0, Simplify.constTrue0);
    const36 = termFactory.makeString("--generate-if-assertions          (2) Generate assertions from if statements");
    constGenerate_loop_assertions0 = termFactory.makeAppl(Simplify._consGenerate_loop_assertions_0, NO_TERMS);
    const37 = termFactory.makeTuple(Simplify.constGenerate_loop_assertions0, Simplify.constTrue0);
    const38 = termFactory.makeString("--generate-loop-assertions        (2) Generate assertions from loop statements");
    constUse_program_assertions0 = termFactory.makeAppl(Simplify._consUse_program_assertions_0, NO_TERMS);
    const39 = termFactory.makeTuple(Simplify.constUse_program_assertions0, Simplify.constTrue0);
    const40 = termFactory.makeString("--use-program-assertions          (2) Use assertions found in source program");
    constUse_apply_assertions0 = termFactory.makeAppl(Simplify._consUse_apply_assertions_0, NO_TERMS);
    const41 = termFactory.makeTuple(Simplify.constUse_apply_assertions0, Simplify.constTrue0);
    const42 = termFactory.makeString("--use-apply-assertions            (2) Use assertions generated in apply stage");
    constMerge_complex_multiply0 = termFactory.makeAppl(Simplify._consMerge_complex_multiply_0, NO_TERMS);
    const43 = termFactory.makeTuple(Simplify.constMerge_complex_multiply0, Simplify.constTrue0);
    const44 = termFactory.makeString("--merge-complex-multiply          Merge multiplications involving complex expressions such as 2 * (a+b) + 3 * (a+b)");
    constNo_evaluate_constant_expressions0 = termFactory.makeAppl(Simplify._consNo_evaluate_constant_expressions_0, NO_TERMS);
    const45 = termFactory.makeTuple(Simplify.constNo_evaluate_constant_expressions0, Simplify.constTrue0);
    constNo_propagate_constant_assignments0 = termFactory.makeAppl(Simplify._consNo_propagate_constant_assignments_0, NO_TERMS);
    const46 = termFactory.makeTuple(Simplify.constNo_propagate_constant_assignments0, Simplify.constTrue0);
    constNo_normalise_expressions0 = termFactory.makeAppl(Simplify._consNo_normalise_expressions_0, NO_TERMS);
    const47 = termFactory.makeTuple(Simplify.constNo_normalise_expressions0, Simplify.constTrue0);
    constNo_generate_if_assertions0 = termFactory.makeAppl(Simplify._consNo_generate_if_assertions_0, NO_TERMS);
    const48 = termFactory.makeTuple(Simplify.constNo_generate_if_assertions0, Simplify.constTrue0);
    constNo_generate_loop_assertions0 = termFactory.makeAppl(Simplify._consNo_generate_loop_assertions_0, NO_TERMS);
    const49 = termFactory.makeTuple(Simplify.constNo_generate_loop_assertions0, Simplify.constTrue0);
    constNo_use_program_assertions0 = termFactory.makeAppl(Simplify._consNo_use_program_assertions_0, NO_TERMS);
    const50 = termFactory.makeTuple(Simplify.constNo_use_program_assertions0, Simplify.constTrue0);
    constNo_use_apply_assertions0 = termFactory.makeAppl(Simplify._consNo_use_apply_assertions_0, NO_TERMS);
    const51 = termFactory.makeTuple(Simplify.constNo_use_apply_assertions0, Simplify.constTrue0);
    constNil0 = (IStrategoTerm)termFactory.makeList();
    constCons0 = (IStrategoTerm)termFactory.makeListCons(Simplify.constOptimise_10, (IStrategoList)Simplify.constNil0);
    constCons1 = (IStrategoTerm)termFactory.makeListCons(Simplify.constOptimise_00, (IStrategoList)Simplify.constCons0);
    constCons2 = (IStrategoTerm)termFactory.makeListCons(Simplify.constOptimise_20, (IStrategoList)Simplify.constCons1);
    constCons3 = (IStrategoTerm)termFactory.makeListCons(Simplify.constLoop_noindex0, (IStrategoList)Simplify.constNil0);
    constCons4 = (IStrategoTerm)termFactory.makeListCons(Simplify.constLoop_index0, (IStrategoList)Simplify.constCons3);
    constCons5 = (IStrategoTerm)termFactory.makeListCons(Simplify.constLoop_noindex0, (IStrategoList)Simplify.constCons4);
    constCons6 = (IStrategoTerm)termFactory.makeListCons(Simplify.constLoop_20, (IStrategoList)Simplify.constNil0);
    constCons7 = (IStrategoTerm)termFactory.makeListCons(Simplify.constLoop_100, (IStrategoList)Simplify.constCons6);
    constCons8 = (IStrategoTerm)termFactory.makeListCons(Simplify.constLoop_20, (IStrategoList)Simplify.constCons7);
    constCons9 = (IStrategoTerm)termFactory.makeListCons(Simplify.constLoop_10, (IStrategoList)Simplify.constCons8);
    constCons10 = (IStrategoTerm)termFactory.makeListCons(Simplify.constLoop_raster0, (IStrategoList)Simplify.constNil0);
    constCons11 = (IStrategoTerm)termFactory.makeListCons(Simplify.constLoop_block0, (IStrategoList)Simplify.constCons10);
    constCons12 = (IStrategoTerm)termFactory.makeListCons(Simplify.constLoop_raster0, (IStrategoList)Simplify.constCons11);
    constCons13 = (IStrategoTerm)termFactory.makeListCons(Simplify.constOptimise_20, (IStrategoList)Simplify.constNil0);
    constCons14 = (IStrategoTerm)termFactory.makeListCons(Simplify.constOptimise_10, (IStrategoList)Simplify.constCons13);
    constCons15 = (IStrategoTerm)termFactory.makeListCons(Simplify.constOptimise_00, (IStrategoList)Simplify.constCons14);
    const52 = termFactory.makeString("Remove");
    const53 = termFactory.makeString("0");
    const54 = termFactory.makeString("1");
    constInt0 = termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{Simplify.const54});
    const55 = termFactory.makeString("Assertion2");
    constDR_DUMMY0 = termFactory.makeAppl(Simplify._consDR_DUMMY_0, NO_TERMS);
    constCons16 = (IStrategoTerm)termFactory.makeListCons(Simplify.constDR_DUMMY0, (IStrategoList)Simplify.constNil0);
    constInt1 = termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{Simplify.constCons16});
    const56 = termFactory.annotateTerm(Simplify.constInt1, checkListAnnos(termFactory, Simplify.constCons16));
    const57 = termFactory.makeString("Assertion3");
    const58 = termFactory.makeString("Assertion4");
    const59 = termFactory.makeString("Assertion5");
    const60 = termFactory.makeString("Assertion6");
    const61 = termFactory.makeString("Assertion7");
    const62 = termFactory.makeString("Assertion1");
    const63 = termFactory.makeString("assert withdraw: ");
    const64 = termFactory.makeString("UsedInAssertion");
    const65 = termFactory.makeString("-74369");
    const66 = termFactory.makeString("assert gt: ");
    const67 = termFactory.makeString("74153");
    const68 = termFactory.makeString("-402069");
    const69 = termFactory.makeString("-342547");
    const70 = termFactory.makeString("-409529");
    const71 = termFactory.makeString("-64755");
    const72 = termFactory.makeString("-718286");
    const73 = termFactory.makeString("assert geq: ");
    const74 = termFactory.makeString("74384");
    const75 = termFactory.makeString("-401954");
    const76 = termFactory.makeString("-342316");
    const77 = termFactory.makeString("-409298");
    const78 = termFactory.makeString("-64523");
    const79 = termFactory.makeString("-718170");
    const80 = termFactory.makeString("assert leq: ");
    const81 = termFactory.makeString("-177112");
    const82 = termFactory.makeString("167662");
    const83 = termFactory.makeString("-343935");
    const84 = termFactory.makeString("-160809");
    const85 = termFactory.makeString("-637146");
    const86 = termFactory.makeString("-719674");
    const87 = termFactory.makeString("assert lt: ");
    const88 = termFactory.makeString("-176534");
    const89 = termFactory.makeString("168240");
    const90 = termFactory.makeString("-343357");
    const91 = termFactory.makeString("-160230");
    const92 = termFactory.makeString("-636568");
    const93 = termFactory.makeString("-719095");
    const94 = termFactory.makeString("assert neq: ");
    const95 = termFactory.makeString("-341622");
    const96 = termFactory.makeString("-717360");
    const97 = termFactory.makeString("assert equ: ");
    const98 = termFactory.makeString("10393");
    const99 = termFactory.makeString("-394164");
    const100 = termFactory.makeString("-80979");
    const101 = termFactory.makeString("-142578");
    const102 = termFactory.makeString("-215837");
    const103 = termFactory.makeString("-298364");
    const104 = termFactory.makeString("-36342");
    const105 = termFactory.makeString("False assertion: assertion conflicts with other assertions and/or constant propagation: ");
    const106 = termFactory.makeString("True assertion ignored: ");
    const107 = termFactory.makeString("-1");
    constInt2 = termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{Simplify.const107});
    constInt3 = termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{Simplify.const53});
    constFalse0 = termFactory.makeAppl(Simplify._consFalse_0, NO_TERMS);
    const108 = termFactory.makeString("2");
    const109 = termFactory.makeString("3");
    const110 = termFactory.makeString("4");
    const111 = termFactory.makeString("5");
    const112 = termFactory.makeString("add-assertions failed");
    const113 = termFactory.makeString("propagate-constant failed");
    const114 = termFactory.makeString("beautify failed");
    const115 = termFactory.makeString("remove-duplicate-assertions failed");
    const116 = termFactory.makeString("PropagateConstant");
    const117 = termFactory.makeString("-615148");
    const118 = termFactory.makeString("assert: ");
    constCons17 = (IStrategoTerm)termFactory.makeListCons(Simplify.const61, (IStrategoList)Simplify.constNil0);
    constCons18 = (IStrategoTerm)termFactory.makeListCons(Simplify.const60, (IStrategoList)Simplify.constCons17);
    constCons19 = (IStrategoTerm)termFactory.makeListCons(Simplify.const59, (IStrategoList)Simplify.constCons18);
    constCons20 = (IStrategoTerm)termFactory.makeListCons(Simplify.const58, (IStrategoList)Simplify.constCons19);
    constCons21 = (IStrategoTerm)termFactory.makeListCons(Simplify.const57, (IStrategoList)Simplify.constCons20);
    constCons22 = (IStrategoTerm)termFactory.makeListCons(Simplify.const55, (IStrategoList)Simplify.constCons21);
    constCons23 = (IStrategoTerm)termFactory.makeListCons(Simplify.const62, (IStrategoList)Simplify.constCons22);
    constCons24 = (IStrategoTerm)termFactory.makeListCons(Simplify.const116, (IStrategoList)Simplify.constCons23);
    const119 = termFactory.makeString("For: ");
    const120 = termFactory.makeString("inside for loop");
    const121 = termFactory.makeString("end for: ");
    constStatements0 = termFactory.makeAppl(Simplify._consStatements_1, new IStrategoTerm[]{Simplify.constNil0});
  }

  @SuppressWarnings("all") public static class get_option_0_1 extends Strategy 
  { 
    public static get_option_0_1 instance = new get_option_0_1();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term, IStrategoTerm y_24)
    { 
      ITermFactory termFactory = context.getFactory();
      context.push("get_option_0_1");
      Fail0:
      { 
        IStrategoTerm z_24 = null;
        IStrategoTerm a_25 = null;
        a_25 = term;
        term = try_1_0.instance.invoke(context, y_24, get_config_0_0.instance);
        if(term == null)
          break Fail0;
        z_24 = term;
        term = termFactory.makeTuple(Simplify.const0, termFactory.makeTuple(y_24, z_24));
        term = debug_options_0_0.instance.invoke(context, term);
        if(term == null)
          break Fail0;
        term = get_config_0_0.instance.invoke(context, y_24);
        if(term == null)
          break Fail0;
        term = a_25;
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class debug_options_0_0 extends Strategy 
  { 
    public static debug_options_0_0 instance = new debug_options_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail1:
      { 
        if(true)
          return term;
      }
      context.push("debug_options_0_0");
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class options_io_wrap_1_0 extends Strategy 
  { 
    public static options_io_wrap_1_0 instance = new options_io_wrap_1_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term, Strategy c_25)
    { 
      context.push("options_io_wrap_1_0");
      Fail2:
      { 
        lifted2 lifted288 = new lifted2();
        lifted288.c_25 = c_25;
        term = io_wrap_2_0.instance.invoke(context, term, set_options_0_0.instance, lifted288);
        if(term == null)
          break Fail2;
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class set_options_0_0 extends Strategy 
  { 
    public static set_options_0_0 instance = new set_options_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      context.push("set_options_0_0");
      Fail3:
      { 
        IStrategoTerm term0 = term;
        Success0:
        { 
          Fail4:
          { 
            term = $Option_3_0.instance.invoke(context, term, lifted3.instance, lifted4.instance, lifted5.instance);
            if(term == null)
              break Fail4;
            if(true)
              break Success0;
          }
          term = term0;
          IStrategoTerm term1 = term;
          Success1:
          { 
            Fail5:
            { 
              term = $Option_3_0.instance.invoke(context, term, lifted6.instance, lifted7.instance, lifted8.instance);
              if(term == null)
                break Fail5;
              if(true)
                break Success1;
            }
            term = term1;
            IStrategoTerm term2 = term;
            Success2:
            { 
              Fail6:
              { 
                term = $Option_3_0.instance.invoke(context, term, lifted9.instance, lifted10.instance, lifted11.instance);
                if(term == null)
                  break Fail6;
                if(true)
                  break Success2;
              }
              term = term2;
              IStrategoTerm term3 = term;
              Success3:
              { 
                Fail7:
                { 
                  term = $Option_3_0.instance.invoke(context, term, lifted12.instance, lifted13.instance, lifted14.instance);
                  if(term == null)
                    break Fail7;
                  if(true)
                    break Success3;
                }
                term = term3;
                IStrategoTerm term4 = term;
                Success4:
                { 
                  Fail8:
                  { 
                    term = $Option_3_0.instance.invoke(context, term, lifted15.instance, lifted16.instance, lifted17.instance);
                    if(term == null)
                      break Fail8;
                    if(true)
                      break Success4;
                  }
                  term = term4;
                  IStrategoTerm term5 = term;
                  Success5:
                  { 
                    Fail9:
                    { 
                      term = $Option_3_0.instance.invoke(context, term, lifted18.instance, lifted19.instance, lifted20.instance);
                      if(term == null)
                        break Fail9;
                      if(true)
                        break Success5;
                    }
                    term = term5;
                    IStrategoTerm term6 = term;
                    Success6:
                    { 
                      Fail10:
                      { 
                        term = $Option_3_0.instance.invoke(context, term, lifted21.instance, lifted22.instance, lifted23.instance);
                        if(term == null)
                          break Fail10;
                        if(true)
                          break Success6;
                      }
                      term = term6;
                      IStrategoTerm term7 = term;
                      Success7:
                      { 
                        Fail11:
                        { 
                          term = $Option_3_0.instance.invoke(context, term, lifted24.instance, lifted25.instance, lifted26.instance);
                          if(term == null)
                            break Fail11;
                          if(true)
                            break Success7;
                        }
                        term = term7;
                        IStrategoTerm term8 = term;
                        Success8:
                        { 
                          Fail12:
                          { 
                            term = $Option_3_0.instance.invoke(context, term, lifted27.instance, lifted28.instance, lifted29.instance);
                            if(term == null)
                              break Fail12;
                            if(true)
                              break Success8;
                          }
                          term = term8;
                          IStrategoTerm term9 = term;
                          Success9:
                          { 
                            Fail13:
                            { 
                              term = $Option_3_0.instance.invoke(context, term, lifted30.instance, lifted31.instance, lifted32.instance);
                              if(term == null)
                                break Fail13;
                              if(true)
                                break Success9;
                            }
                            term = term9;
                            IStrategoTerm term10 = term;
                            Success10:
                            { 
                              Fail14:
                              { 
                                term = $Option_3_0.instance.invoke(context, term, lifted33.instance, lifted34.instance, lifted35.instance);
                                if(term == null)
                                  break Fail14;
                                if(true)
                                  break Success10;
                              }
                              term = term10;
                              IStrategoTerm term11 = term;
                              Success11:
                              { 
                                Fail15:
                                { 
                                  term = $Option_3_0.instance.invoke(context, term, lifted36.instance, lifted37.instance, lifted38.instance);
                                  if(term == null)
                                    break Fail15;
                                  if(true)
                                    break Success11;
                                }
                                term = term11;
                                IStrategoTerm term12 = term;
                                Success12:
                                { 
                                  Fail16:
                                  { 
                                    term = $Option_3_0.instance.invoke(context, term, lifted39.instance, lifted40.instance, lifted41.instance);
                                    if(term == null)
                                      break Fail16;
                                    if(true)
                                      break Success12;
                                  }
                                  term = term12;
                                  IStrategoTerm term13 = term;
                                  Success13:
                                  { 
                                    Fail17:
                                    { 
                                      term = $Option_3_0.instance.invoke(context, term, lifted42.instance, lifted43.instance, lifted44.instance);
                                      if(term == null)
                                        break Fail17;
                                      if(true)
                                        break Success13;
                                    }
                                    term = term13;
                                    IStrategoTerm term14 = term;
                                    Success14:
                                    { 
                                      Fail18:
                                      { 
                                        term = $Option_3_0.instance.invoke(context, term, lifted45.instance, lifted46.instance, lifted47.instance);
                                        if(term == null)
                                          break Fail18;
                                        if(true)
                                          break Success14;
                                      }
                                      term = term14;
                                      IStrategoTerm term15 = term;
                                      Success15:
                                      { 
                                        Fail19:
                                        { 
                                          term = $Option_3_0.instance.invoke(context, term, lifted48.instance, lifted49.instance, lifted50.instance);
                                          if(term == null)
                                            break Fail19;
                                          if(true)
                                            break Success15;
                                        }
                                        term = term15;
                                        IStrategoTerm term16 = term;
                                        Success16:
                                        { 
                                          Fail20:
                                          { 
                                            term = $Option_3_0.instance.invoke(context, term, lifted51.instance, lifted52.instance, lifted53.instance);
                                            if(term == null)
                                              break Fail20;
                                            if(true)
                                              break Success16;
                                          }
                                          term = term16;
                                          IStrategoTerm term17 = term;
                                          Success17:
                                          { 
                                            Fail21:
                                            { 
                                              term = $Option_3_0.instance.invoke(context, term, lifted54.instance, lifted55.instance, lifted56.instance);
                                              if(term == null)
                                                break Fail21;
                                              if(true)
                                                break Success17;
                                            }
                                            term = term17;
                                            IStrategoTerm term18 = term;
                                            Success18:
                                            { 
                                              Fail22:
                                              { 
                                                term = $Option_3_0.instance.invoke(context, term, lifted57.instance, lifted58.instance, lifted59.instance);
                                                if(term == null)
                                                  break Fail22;
                                                if(true)
                                                  break Success18;
                                              }
                                              term = term18;
                                              IStrategoTerm term19 = term;
                                              Success19:
                                              { 
                                                Fail23:
                                                { 
                                                  term = $Option_3_0.instance.invoke(context, term, lifted60.instance, lifted61.instance, lifted62.instance);
                                                  if(term == null)
                                                    break Fail23;
                                                  if(true)
                                                    break Success19;
                                                }
                                                term = term19;
                                                IStrategoTerm term20 = term;
                                                Success20:
                                                { 
                                                  Fail24:
                                                  { 
                                                    term = $Option_3_0.instance.invoke(context, term, lifted63.instance, lifted64.instance, lifted65.instance);
                                                    if(term == null)
                                                      break Fail24;
                                                    if(true)
                                                      break Success20;
                                                  }
                                                  term = term20;
                                                  IStrategoTerm term21 = term;
                                                  Success21:
                                                  { 
                                                    Fail25:
                                                    { 
                                                      term = $Option_3_0.instance.invoke(context, term, lifted66.instance, lifted67.instance, lifted68.instance);
                                                      if(term == null)
                                                        break Fail25;
                                                      if(true)
                                                        break Success21;
                                                    }
                                                    term = term21;
                                                    IStrategoTerm term22 = term;
                                                    Success22:
                                                    { 
                                                      Fail26:
                                                      { 
                                                        term = $Option_3_0.instance.invoke(context, term, lifted69.instance, lifted70.instance, lifted71.instance);
                                                        if(term == null)
                                                          break Fail26;
                                                        if(true)
                                                          break Success22;
                                                      }
                                                      term = term22;
                                                      IStrategoTerm term23 = term;
                                                      Success23:
                                                      { 
                                                        Fail27:
                                                        { 
                                                          term = $Option_3_0.instance.invoke(context, term, lifted72.instance, lifted73.instance, lifted74.instance);
                                                          if(term == null)
                                                            break Fail27;
                                                          if(true)
                                                            break Success23;
                                                        }
                                                        term = term23;
                                                        IStrategoTerm term24 = term;
                                                        Success24:
                                                        { 
                                                          Fail28:
                                                          { 
                                                            term = $Option_3_0.instance.invoke(context, term, lifted75.instance, lifted76.instance, lifted77.instance);
                                                            if(term == null)
                                                              break Fail28;
                                                            if(true)
                                                              break Success24;
                                                          }
                                                          term = term24;
                                                          IStrategoTerm term25 = term;
                                                          Success25:
                                                          { 
                                                            Fail29:
                                                            { 
                                                              term = $Option_3_0.instance.invoke(context, term, lifted78.instance, lifted79.instance, lifted80.instance);
                                                              if(term == null)
                                                                break Fail29;
                                                              if(true)
                                                                break Success25;
                                                            }
                                                            term = term25;
                                                            IStrategoTerm term26 = term;
                                                            Success26:
                                                            { 
                                                              Fail30:
                                                              { 
                                                                term = $Option_3_0.instance.invoke(context, term, lifted81.instance, lifted82.instance, lifted83.instance);
                                                                if(term == null)
                                                                  break Fail30;
                                                                if(true)
                                                                  break Success26;
                                                              }
                                                              term = term26;
                                                              IStrategoTerm term27 = term;
                                                              Success27:
                                                              { 
                                                                Fail31:
                                                                { 
                                                                  term = $Option_3_0.instance.invoke(context, term, lifted84.instance, lifted85.instance, lifted86.instance);
                                                                  if(term == null)
                                                                    break Fail31;
                                                                  if(true)
                                                                    break Success27;
                                                                }
                                                                term = $Option_3_0.instance.invoke(context, term27, lifted87.instance, lifted88.instance, lifted89.instance);
                                                                if(term == null)
                                                                  break Fail3;
                                                              }
                                                            }
                                                          }
                                                        }
                                                      }
                                                    }
                                                  }
                                                }
                                              }
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class do_defaults_1_0 extends Strategy 
  { 
    public static do_defaults_1_0 instance = new do_defaults_1_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term, Strategy e_25)
    { 
      context.push("do_defaults_1_0");
      Fail32:
      { 
        IStrategoTerm d_25 = null;
        d_25 = term;
        term = try_1_0.instance.invoke(context, term, lifted90.instance);
        if(term == null)
          break Fail32;
        term = try_1_0.instance.invoke(context, term, lifted91.instance);
        if(term == null)
          break Fail32;
        term = try_1_0.instance.invoke(context, term, lifted93.instance);
        if(term == null)
          break Fail32;
        term = try_1_0.instance.invoke(context, term, lifted94.instance);
        if(term == null)
          break Fail32;
        term = try_1_0.instance.invoke(context, term, lifted95.instance);
        if(term == null)
          break Fail32;
        term = try_1_0.instance.invoke(context, term, lifted96.instance);
        if(term == null)
          break Fail32;
        term = try_1_0.instance.invoke(context, term, lifted97.instance);
        if(term == null)
          break Fail32;
        term = try_1_0.instance.invoke(context, term, lifted98.instance);
        if(term == null)
          break Fail32;
        term = try_1_0.instance.invoke(context, term, lifted99.instance);
        if(term == null)
          break Fail32;
        term = try_1_0.instance.invoke(context, term, lifted100.instance);
        if(term == null)
          break Fail32;
        term = try_1_0.instance.invoke(context, term, lifted101.instance);
        if(term == null)
          break Fail32;
        term = try_1_0.instance.invoke(context, term, lifted102.instance);
        if(term == null)
          break Fail32;
        term = try_1_0.instance.invoke(context, term, lifted103.instance);
        if(term == null)
          break Fail32;
        term = try_1_0.instance.invoke(context, term, lifted104.instance);
        if(term == null)
          break Fail32;
        term = try_1_0.instance.invoke(context, term, lifted105.instance);
        if(term == null)
          break Fail32;
        term = e_25.invoke(context, d_25);
        if(term == null)
          break Fail32;
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class option_group_default_0_0 extends Strategy 
  { 
    public static option_group_default_0_0 instance = new option_group_default_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      context.push("option_group_default_0_0");
      Fail33:
      { 
        IStrategoTerm term28 = term;
        Success28:
        { 
          Fail34:
          { 
            term = option_group_default_last_0_0.instance.invoke(context, term);
            if(term == null)
              break Fail34;
            if(true)
              break Success28;
          }
          term = option_group_default_more_0_0.instance.invoke(context, term28);
          if(term == null)
            break Fail33;
        }
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class option_group_default_last_0_0 extends Strategy 
  { 
    public static option_group_default_last_0_0 instance = new option_group_default_last_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      ITermFactory termFactory = context.getFactory();
      context.push("option_group_default_last_0_0");
      Fail35:
      { 
        IStrategoTerm b_26 = null;
        if(term.getTermType() != IStrategoTerm.LIST || ((IStrategoList)term).isEmpty())
          break Fail35;
        b_26 = ((IStrategoList)term).head();
        IStrategoTerm arg0 = ((IStrategoList)term).tail();
        if(arg0.getTermType() != IStrategoTerm.LIST || !((IStrategoList)arg0).isEmpty())
          break Fail35;
        IStrategoTerm term29 = term;
        Success29:
        { 
          Fail36:
          { 
            IStrategoTerm c_26 = null;
            c_26 = term;
            term = b_26;
            IStrategoTerm term30 = term;
            Success30:
            { 
              Fail37:
              { 
                term = get_config_0_0.instance.invoke(context, term);
                if(term == null)
                  break Fail37;
                { 
                  if(true)
                    break Fail36;
                  if(true)
                    break Success30;
                }
              }
              term = term30;
            }
            term = c_26;
            { 
              IStrategoTerm d_26 = null;
              term = termFactory.makeTuple(b_26, Simplify.constTrue0);
              term = set_config_0_0.instance.invoke(context, term);
              if(term == null)
                break Fail35;
              d_26 = term;
              term = termFactory.makeTuple(b_26, Simplify.constTrue0);
              term = debug_options_0_0.instance.invoke(context, term);
              if(term == null)
                break Fail35;
              term = d_26;
              if(true)
                break Success29;
            }
          }
          term = term29;
        }
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class option_group_default_more_0_0 extends Strategy 
  { 
    public static option_group_default_more_0_0 instance = new option_group_default_more_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      context.push("option_group_default_more_0_0");
      Fail38:
      { 
        IStrategoTerm e_26 = null;
        IStrategoTerm f_26 = null;
        if(term.getTermType() != IStrategoTerm.LIST || ((IStrategoList)term).isEmpty())
          break Fail38;
        e_26 = ((IStrategoList)term).head();
        f_26 = ((IStrategoList)term).tail();
        IStrategoTerm term31 = term;
        Success31:
        { 
          Fail39:
          { 
            IStrategoTerm g_26 = null;
            g_26 = term;
            term = e_26;
            IStrategoTerm term32 = term;
            Success32:
            { 
              Fail40:
              { 
                term = get_config_0_0.instance.invoke(context, term);
                if(term == null)
                  break Fail40;
                { 
                  if(true)
                    break Fail39;
                  if(true)
                    break Success32;
                }
              }
              term = term32;
            }
            term = g_26;
            { 
              term = option_group_default_0_0.instance.invoke(context, f_26);
              if(term == null)
                break Fail38;
              if(true)
                break Success31;
            }
          }
          term = term31;
        }
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class mutually_exclusive_options_default_0_0 extends Strategy 
  { 
    public static mutually_exclusive_options_default_0_0 instance = new mutually_exclusive_options_default_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      context.push("mutually_exclusive_options_default_0_0");
      Fail41:
      { 
        IStrategoTerm term33 = term;
        Success33:
        { 
          Fail42:
          { 
            term = mutually_exclusive_options_default_last_0_0.instance.invoke(context, term);
            if(term == null)
              break Fail42;
            if(true)
              break Success33;
          }
          term = mutually_exclusive_options_default_more_0_0.instance.invoke(context, term33);
          if(term == null)
            break Fail41;
        }
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class mutually_exclusive_options_default_last_0_0 extends Strategy 
  { 
    public static mutually_exclusive_options_default_last_0_0 instance = new mutually_exclusive_options_default_last_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      ITermFactory termFactory = context.getFactory();
      context.push("mutually_exclusive_options_default_last_0_0");
      Fail43:
      { 
        IStrategoTerm h_26 = null;
        if(term.getTermType() != IStrategoTerm.LIST || ((IStrategoList)term).isEmpty())
          break Fail43;
        h_26 = ((IStrategoList)term).head();
        IStrategoTerm arg1 = ((IStrategoList)term).tail();
        if(arg1.getTermType() != IStrategoTerm.LIST || !((IStrategoList)arg1).isEmpty())
          break Fail43;
        IStrategoTerm term34 = term;
        Success34:
        { 
          Fail44:
          { 
            IStrategoTerm i_26 = null;
            i_26 = term;
            term = h_26;
            IStrategoTerm term35 = term;
            Success35:
            { 
              Fail45:
              { 
                term = get_config_0_0.instance.invoke(context, term);
                if(term == null)
                  break Fail45;
                { 
                  if(true)
                    break Fail44;
                  if(true)
                    break Success35;
                }
              }
              term = term35;
            }
            term = i_26;
            { 
              IStrategoTerm j_26 = null;
              term = termFactory.makeTuple(h_26, Simplify.constTrue0);
              term = set_config_0_0.instance.invoke(context, term);
              if(term == null)
                break Fail43;
              j_26 = term;
              term = termFactory.makeTuple(h_26, Simplify.constTrue0);
              term = debug_options_0_0.instance.invoke(context, term);
              if(term == null)
                break Fail43;
              term = j_26;
              if(true)
                break Success34;
            }
          }
          term = term34;
        }
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class mutually_exclusive_options_default_more_0_0 extends Strategy 
  { 
    public static mutually_exclusive_options_default_more_0_0 instance = new mutually_exclusive_options_default_more_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      context.push("mutually_exclusive_options_default_more_0_0");
      Fail46:
      { 
        IStrategoTerm k_26 = null;
        IStrategoTerm l_26 = null;
        if(term.getTermType() != IStrategoTerm.LIST || ((IStrategoList)term).isEmpty())
          break Fail46;
        l_26 = ((IStrategoList)term).head();
        k_26 = ((IStrategoList)term).tail();
        Success36:
        { 
          Fail47:
          { 
            IStrategoTerm m_26 = null;
            m_26 = term;
            term = l_26;
            IStrategoTerm term37 = term;
            Success37:
            { 
              Fail48:
              { 
                term = get_config_0_0.instance.invoke(context, term);
                if(term == null)
                  break Fail48;
                { 
                  if(true)
                    break Fail47;
                  if(true)
                    break Success37;
                }
              }
              term = term37;
            }
            term = m_26;
            { 
              term = mutually_exclusive_options_default_0_0.instance.invoke(context, k_26);
              if(term == null)
                break Fail46;
              if(true)
                break Success36;
            }
          }
          term = cancel_duplicates_0_1.instance.invoke(context, k_26, l_26);
          if(term == null)
            break Fail46;
        }
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class cancel_duplicates_0_1 extends Strategy 
  { 
    public static cancel_duplicates_0_1 instance = new cancel_duplicates_0_1();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term, IStrategoTerm n_26)
    { 
      ITermFactory termFactory = context.getFactory();
      context.push("cancel_duplicates_0_1");
      Fail49:
      { 
        TermReference o_26 = new TermReference();
        IStrategoTerm p_26 = null;
        if(term.getTermType() != IStrategoTerm.LIST || ((IStrategoList)term).isEmpty())
          break Fail49;
        if(o_26.value == null)
          o_26.value = ((IStrategoList)term).head();
        else
          if(o_26.value != ((IStrategoList)term).head() && !o_26.value.match(((IStrategoList)term).head()))
            break Fail49;
        p_26 = ((IStrategoList)term).tail();
        IStrategoTerm term38 = term;
        Success38:
        { 
          Fail50:
          { 
            IStrategoTerm q_26 = null;
            q_26 = term;
            if(term.getTermType() != IStrategoTerm.LIST || ((IStrategoList)term).isEmpty())
              break Fail50;
            if(((IStrategoList)term).head() != n_26 && !n_26.match(((IStrategoList)term).head()))
              break Fail50;
            term = q_26;
            { 
              term = this.invoke(context, p_26, n_26);
              if(term == null)
                break Fail49;
              if(true)
                break Success38;
            }
          }
          term = term38;
          lifted106 lifted1060 = new lifted106();
          lifted1060.o_26 = o_26;
          term = try_1_0.instance.invoke(context, term, lifted1060);
          if(term == null)
            break Fail49;
          if(o_26.value == null)
            break Fail49;
          term = termFactory.makeTuple(Simplify.const52, o_26.value);
          term = debug_options_0_0.instance.invoke(context, term);
          if(term == null)
            break Fail49;
          term = this.invoke(context, p_26, n_26);
          if(term == null)
            break Fail49;
        }
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class beautify_0_0 extends Strategy 
  { 
    public static beautify_0_0 instance = new beautify_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      context.push("beautify_0_0");
      Fail51:
      { 
        term = o_416.instance.invoke(context, term, p_416.instance);
        if(term == null)
          break Fail51;
        term = g_418.instance.invoke(context, term, h_418.instance);
        if(term == null)
          break Fail51;
        term = u_423.instance.invoke(context, term, v_423.instance);
        if(term == null)
          break Fail51;
        term = k_424.instance.invoke(context, term, l_424.instance);
        if(term == null)
          break Fail51;
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class $Neg$Mul$Const_0_0 extends Strategy 
  { 
    public static $Neg$Mul$Const_0_0 instance = new $Neg$Mul$Const_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      ITermFactory termFactory = context.getFactory();
      context.push("NegMulConst_0_0");
      Fail52:
      { 
        IStrategoTerm term72 = term;
        IStrategoConstructor cons0 = term.getTermType() == IStrategoTerm.APPL ? ((IStrategoAppl)term).getConstructor() : null;
        Success39:
        { 
          if(cons0 == Simplify._consMul_2)
          { 
            Fail53:
            { 
              IStrategoTerm y_27 = null;
              IStrategoTerm z_27 = null;
              IStrategoTerm arg57 = term.getSubterm(0);
              if(arg57.getTermType() != IStrategoTerm.APPL || Simplify._consNeg_1 != ((IStrategoAppl)arg57).getConstructor())
                break Fail53;
              y_27 = arg57.getSubterm(0);
              IStrategoTerm arg58 = term.getSubterm(1);
              if(arg58.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg58).getConstructor())
                break Fail53;
              z_27 = arg58.getSubterm(0);
              term = termFactory.makeAppl(Simplify._consNeg_1, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{y_27, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{z_27})})});
              if(true)
                break Success39;
            }
            term = term72;
          }
          Success40:
          { 
            if(cons0 == Simplify._consMul_2)
            { 
              Fail54:
              { 
                IStrategoTerm u_27 = null;
                IStrategoTerm v_27 = null;
                u_27 = term.getSubterm(0);
                IStrategoTerm arg59 = term.getSubterm(1);
                if(arg59.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg59).getConstructor())
                  break Fail54;
                v_27 = arg59.getSubterm(0);
                term = termFactory.makeTuple(v_27, Simplify.const53);
                term = lt$S_0_0.instance.invoke(context, term);
                if(term == null)
                  break Fail54;
                term = termFactory.makeTuple(Simplify.const53, v_27);
                term = subt$S_0_0.instance.invoke(context, term);
                if(term == null)
                  break Fail54;
                term = termFactory.makeAppl(Simplify._consNeg_1, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{u_27, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{term})})});
                if(true)
                  break Success40;
              }
              term = term72;
            }
            if(cons0 == Simplify._consNeg_1)
            { 
              IStrategoTerm s_27 = null;
              s_27 = term.getSubterm(0);
              term = s_27;
              IStrategoTerm term74 = term;
              Success41:
              { 
                Fail55:
                { 
                  if(term.getTermType() != IStrategoTerm.APPL || Simplify._consMul_2 != ((IStrategoAppl)term).getConstructor())
                    break Fail55;
                  IStrategoTerm arg61 = term.getSubterm(1);
                  if(arg61.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg61).getConstructor())
                    break Fail55;
                  { 
                    if(true)
                      break Fail52;
                    if(true)
                      break Success41;
                  }
                }
                term = term74;
              }
              term = s_27;
              IStrategoTerm term75 = term;
              Success42:
              { 
                Fail56:
                { 
                  if(term.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)term).getConstructor())
                    break Fail56;
                  { 
                    if(true)
                      break Fail52;
                    if(true)
                      break Success42;
                  }
                }
                term = term75;
              }
              term = termFactory.makeAppl(Simplify._consNeg_1, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{s_27, Simplify.constInt0})});
            }
            else
            { 
              break Fail52;
            }
          }
        }
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class $Sort$Neg_0_0 extends Strategy 
  { 
    public static $Sort$Neg_0_0 instance = new $Sort$Neg_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      ITermFactory termFactory = context.getFactory();
      context.push("SortNeg_0_0");
      Fail57:
      { 
        IStrategoTerm term76 = term;
        IStrategoConstructor cons3 = term.getTermType() == IStrategoTerm.APPL ? ((IStrategoAppl)term).getConstructor() : null;
        Success43:
        { 
          if(cons3 == Simplify._consAdd_2)
          { 
            Fail58:
            { 
              IStrategoTerm n_28 = null;
              IStrategoTerm o_28 = null;
              IStrategoTerm arg64 = term.getSubterm(0);
              if(arg64.getTermType() != IStrategoTerm.APPL || Simplify._consNeg_1 != ((IStrategoAppl)arg64).getConstructor())
                break Fail58;
              n_28 = arg64.getSubterm(0);
              o_28 = term.getSubterm(1);
              term = o_28;
              IStrategoTerm term77 = term;
              Success44:
              { 
                Fail59:
                { 
                  if(term.getTermType() != IStrategoTerm.APPL || Simplify._consNeg_1 != ((IStrategoAppl)term).getConstructor())
                    break Fail59;
                  { 
                    if(true)
                      break Fail58;
                    if(true)
                      break Success44;
                  }
                }
                term = term77;
              }
              term = o_28;
              IStrategoTerm term78 = term;
              Success45:
              { 
                Fail60:
                { 
                  if(term.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)term).getConstructor())
                    break Fail60;
                  { 
                    if(true)
                      break Fail58;
                    if(true)
                      break Success45;
                  }
                }
                term = term78;
              }
              term = termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{o_28, termFactory.makeAppl(Simplify._consNeg_1, new IStrategoTerm[]{n_28})});
              if(true)
                break Success43;
            }
            term = term76;
          }
          Success46:
          { 
            if(cons3 == Simplify._consAdd_2)
            { 
              Fail61:
              { 
                IStrategoTerm j_28 = null;
                IStrategoTerm k_28 = null;
                IStrategoTerm l_28 = null;
                IStrategoTerm arg67 = term.getSubterm(0);
                if(arg67.getTermType() != IStrategoTerm.APPL || Simplify._consAdd_2 != ((IStrategoAppl)arg67).getConstructor())
                  break Fail61;
                j_28 = arg67.getSubterm(0);
                IStrategoTerm arg68 = arg67.getSubterm(1);
                if(arg68.getTermType() != IStrategoTerm.APPL || Simplify._consNeg_1 != ((IStrategoAppl)arg68).getConstructor())
                  break Fail61;
                k_28 = arg68.getSubterm(0);
                l_28 = term.getSubterm(1);
                term = l_28;
                IStrategoTerm term80 = term;
                Success47:
                { 
                  Fail62:
                  { 
                    if(term.getTermType() != IStrategoTerm.APPL || Simplify._consNeg_1 != ((IStrategoAppl)term).getConstructor())
                      break Fail62;
                    { 
                      if(true)
                        break Fail61;
                      if(true)
                        break Success47;
                    }
                  }
                  term = term80;
                }
                term = l_28;
                IStrategoTerm term81 = term;
                Success48:
                { 
                  Fail63:
                  { 
                    if(term.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)term).getConstructor())
                      break Fail63;
                    { 
                      if(true)
                        break Fail61;
                      if(true)
                        break Success48;
                    }
                  }
                  term = term81;
                }
                term = termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{j_28, l_28}), termFactory.makeAppl(Simplify._consNeg_1, new IStrategoTerm[]{k_28})});
                if(true)
                  break Success46;
              }
              term = term76;
            }
            Success49:
            { 
              if(cons3 == Simplify._consAdd_2)
              { 
                Fail64:
                { 
                  IStrategoTerm f_28 = null;
                  IStrategoTerm g_28 = null;
                  IStrategoTerm h_28 = null;
                  IStrategoTerm arg71 = term.getSubterm(0);
                  if(arg71.getTermType() != IStrategoTerm.APPL || Simplify._consNeg_1 != ((IStrategoAppl)arg71).getConstructor())
                    break Fail64;
                  IStrategoTerm arg72 = arg71.getSubterm(0);
                  if(arg72.getTermType() != IStrategoTerm.APPL || Simplify._consMul_2 != ((IStrategoAppl)arg72).getConstructor())
                    break Fail64;
                  g_28 = arg72.getSubterm(0);
                  IStrategoTerm arg73 = arg72.getSubterm(1);
                  if(arg73.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg73).getConstructor())
                    break Fail64;
                  IStrategoTerm arg74 = arg73.getSubterm(0);
                  if(arg74.getTermType() != IStrategoTerm.STRING || !"1".equals(((IStrategoString)arg74).stringValue()))
                    break Fail64;
                  IStrategoTerm arg75 = term.getSubterm(1);
                  if(arg75.getTermType() != IStrategoTerm.APPL || Simplify._consNeg_1 != ((IStrategoAppl)arg75).getConstructor())
                    break Fail64;
                  IStrategoTerm arg76 = arg75.getSubterm(0);
                  if(arg76.getTermType() != IStrategoTerm.APPL || Simplify._consMul_2 != ((IStrategoAppl)arg76).getConstructor())
                    break Fail64;
                  f_28 = arg76.getSubterm(0);
                  IStrategoTerm arg77 = arg76.getSubterm(1);
                  if(arg77.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg77).getConstructor())
                    break Fail64;
                  h_28 = arg77.getSubterm(0);
                  term = termFactory.makeTuple(h_28, Simplify.const54);
                  term = gt$S_0_0.instance.invoke(context, term);
                  if(term == null)
                    break Fail64;
                  term = termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consNeg_1, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{f_28, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{h_28})})}), termFactory.makeAppl(Simplify._consNeg_1, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{g_28, Simplify.constInt0})})});
                  if(true)
                    break Success49;
                }
                term = term76;
              }
              if(cons3 == Simplify._consAdd_2)
              { 
                IStrategoTerm a_28 = null;
                IStrategoTerm b_28 = null;
                IStrategoTerm c_28 = null;
                IStrategoTerm d_28 = null;
                IStrategoTerm arg78 = term.getSubterm(0);
                if(arg78.getTermType() != IStrategoTerm.APPL || Simplify._consAdd_2 != ((IStrategoAppl)arg78).getConstructor())
                  break Fail57;
                a_28 = arg78.getSubterm(0);
                IStrategoTerm arg79 = arg78.getSubterm(1);
                if(arg79.getTermType() != IStrategoTerm.APPL || Simplify._consNeg_1 != ((IStrategoAppl)arg79).getConstructor())
                  break Fail57;
                IStrategoTerm arg80 = arg79.getSubterm(0);
                if(arg80.getTermType() != IStrategoTerm.APPL || Simplify._consMul_2 != ((IStrategoAppl)arg80).getConstructor())
                  break Fail57;
                c_28 = arg80.getSubterm(0);
                IStrategoTerm arg81 = arg80.getSubterm(1);
                if(arg81.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg81).getConstructor())
                  break Fail57;
                IStrategoTerm arg82 = arg81.getSubterm(0);
                if(arg82.getTermType() != IStrategoTerm.STRING || !"1".equals(((IStrategoString)arg82).stringValue()))
                  break Fail57;
                IStrategoTerm arg83 = term.getSubterm(1);
                if(arg83.getTermType() != IStrategoTerm.APPL || Simplify._consNeg_1 != ((IStrategoAppl)arg83).getConstructor())
                  break Fail57;
                IStrategoTerm arg84 = arg83.getSubterm(0);
                if(arg84.getTermType() != IStrategoTerm.APPL || Simplify._consMul_2 != ((IStrategoAppl)arg84).getConstructor())
                  break Fail57;
                b_28 = arg84.getSubterm(0);
                IStrategoTerm arg85 = arg84.getSubterm(1);
                if(arg85.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg85).getConstructor())
                  break Fail57;
                d_28 = arg85.getSubterm(0);
                term = termFactory.makeTuple(d_28, Simplify.const54);
                term = gt$S_0_0.instance.invoke(context, term);
                if(term == null)
                  break Fail57;
                term = termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{a_28, termFactory.makeAppl(Simplify._consNeg_1, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{b_28, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{d_28})})})}), termFactory.makeAppl(Simplify._consNeg_1, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{c_28, Simplify.constInt0})})});
              }
              else
              { 
                break Fail57;
              }
            }
          }
        }
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class $Beautify_0_0 extends Strategy 
  { 
    public static $Beautify_0_0 instance = new $Beautify_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      ITermFactory termFactory = context.getFactory();
      context.push("Beautify_0_0");
      Fail65:
      { 
        IStrategoTerm term83 = term;
        IStrategoConstructor cons8 = term.getTermType() == IStrategoTerm.APPL ? ((IStrategoAppl)term).getConstructor() : null;
        Success50:
        { 
          if(cons8 == Simplify._consAdd_2)
          { 
            Fail66:
            { 
              IStrategoTerm p_29 = null;
              IStrategoTerm q_29 = null;
              p_29 = term.getSubterm(0);
              IStrategoTerm arg86 = term.getSubterm(1);
              if(arg86.getTermType() != IStrategoTerm.APPL || Simplify._consNeg_1 != ((IStrategoAppl)arg86).getConstructor())
                break Fail66;
              q_29 = arg86.getSubterm(0);
              term = termFactory.makeAppl(Simplify._consSub_2, new IStrategoTerm[]{p_29, q_29});
              if(true)
                break Success50;
            }
            term = term83;
          }
          Success51:
          { 
            if(cons8 == Simplify._consMul_2)
            { 
              Fail67:
              { 
                IStrategoTerm m_29 = null;
                IStrategoTerm n_29 = null;
                n_29 = term.getSubterm(0);
                IStrategoTerm arg87 = term.getSubterm(1);
                if(arg87.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg87).getConstructor())
                  break Fail67;
                m_29 = arg87.getSubterm(0);
                term = n_29;
                IStrategoTerm term85 = term;
                Success52:
                { 
                  Fail68:
                  { 
                    if(term.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)term).getConstructor())
                      break Fail68;
                    { 
                      if(true)
                        break Fail67;
                      if(true)
                        break Success52;
                    }
                  }
                  term = term85;
                }
                term = termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{m_29}), n_29});
                if(true)
                  break Success51;
              }
              term = term83;
            }
            Success53:
            { 
              if(cons8 == Simplify._consAdd_2)
              { 
                Fail69:
                { 
                  IStrategoTerm i_29 = null;
                  IStrategoTerm j_29 = null;
                  i_29 = term.getSubterm(0);
                  IStrategoTerm arg89 = term.getSubterm(1);
                  if(arg89.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg89).getConstructor())
                    break Fail69;
                  j_29 = arg89.getSubterm(0);
                  term = termFactory.makeTuple(j_29, Simplify.const53);
                  term = lt$S_0_0.instance.invoke(context, term);
                  if(term == null)
                    break Fail69;
                  term = termFactory.makeTuple(Simplify.const53, j_29);
                  term = subt$S_0_0.instance.invoke(context, term);
                  if(term == null)
                    break Fail69;
                  term = termFactory.makeAppl(Simplify._consSub_2, new IStrategoTerm[]{i_29, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{term})});
                  if(true)
                    break Success53;
                }
                term = term83;
              }
              Success54:
              { 
                if(cons8 == Simplify._consGt_2)
                { 
                  Fail70:
                  { 
                    IStrategoTerm f_29 = null;
                    IStrategoTerm g_29 = null;
                    IStrategoTerm h_29 = null;
                    IStrategoTerm arg90 = term.getSubterm(0);
                    if(arg90.getTermType() != IStrategoTerm.APPL || Simplify._consSub_2 != ((IStrategoAppl)arg90).getConstructor())
                      break Fail70;
                    f_29 = arg90.getSubterm(0);
                    g_29 = arg90.getSubterm(1);
                    h_29 = term.getSubterm(1);
                    term = termFactory.makeAppl(Simplify._consGt_2, new IStrategoTerm[]{f_29, termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{g_29, h_29})});
                    if(true)
                      break Success54;
                  }
                  term = term83;
                }
                Success55:
                { 
                  if(cons8 == Simplify._consGeq_2)
                  { 
                    Fail71:
                    { 
                      IStrategoTerm c_29 = null;
                      IStrategoTerm d_29 = null;
                      IStrategoTerm e_29 = null;
                      IStrategoTerm arg91 = term.getSubterm(0);
                      if(arg91.getTermType() != IStrategoTerm.APPL || Simplify._consSub_2 != ((IStrategoAppl)arg91).getConstructor())
                        break Fail71;
                      c_29 = arg91.getSubterm(0);
                      d_29 = arg91.getSubterm(1);
                      e_29 = term.getSubterm(1);
                      term = termFactory.makeAppl(Simplify._consGeq_2, new IStrategoTerm[]{c_29, termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{d_29, e_29})});
                      if(true)
                        break Success55;
                    }
                    term = term83;
                  }
                  Success56:
                  { 
                    if(cons8 == Simplify._consEqu_2)
                    { 
                      Fail72:
                      { 
                        IStrategoTerm z_28 = null;
                        IStrategoTerm a_29 = null;
                        IStrategoTerm b_29 = null;
                        IStrategoTerm arg92 = term.getSubterm(0);
                        if(arg92.getTermType() != IStrategoTerm.APPL || Simplify._consSub_2 != ((IStrategoAppl)arg92).getConstructor())
                          break Fail72;
                        z_28 = arg92.getSubterm(0);
                        a_29 = arg92.getSubterm(1);
                        b_29 = term.getSubterm(1);
                        term = termFactory.makeAppl(Simplify._consEqu_2, new IStrategoTerm[]{z_28, termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{a_29, b_29})});
                        if(true)
                          break Success56;
                      }
                      term = term83;
                    }
                    Success57:
                    { 
                      if(cons8 == Simplify._consLt_2)
                      { 
                        Fail73:
                        { 
                          IStrategoTerm w_28 = null;
                          IStrategoTerm x_28 = null;
                          IStrategoTerm y_28 = null;
                          IStrategoTerm arg93 = term.getSubterm(0);
                          if(arg93.getTermType() != IStrategoTerm.APPL || Simplify._consSub_2 != ((IStrategoAppl)arg93).getConstructor())
                            break Fail73;
                          w_28 = arg93.getSubterm(0);
                          x_28 = arg93.getSubterm(1);
                          y_28 = term.getSubterm(1);
                          term = termFactory.makeAppl(Simplify._consLt_2, new IStrategoTerm[]{w_28, termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{x_28, y_28})});
                          if(true)
                            break Success57;
                        }
                        term = term83;
                      }
                      Success58:
                      { 
                        if(cons8 == Simplify._consLeq_2)
                        { 
                          Fail74:
                          { 
                            IStrategoTerm t_28 = null;
                            IStrategoTerm u_28 = null;
                            IStrategoTerm v_28 = null;
                            IStrategoTerm arg94 = term.getSubterm(0);
                            if(arg94.getTermType() != IStrategoTerm.APPL || Simplify._consSub_2 != ((IStrategoAppl)arg94).getConstructor())
                              break Fail74;
                            t_28 = arg94.getSubterm(0);
                            u_28 = arg94.getSubterm(1);
                            v_28 = term.getSubterm(1);
                            term = termFactory.makeAppl(Simplify._consLeq_2, new IStrategoTerm[]{t_28, termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{u_28, v_28})});
                            if(true)
                              break Success58;
                          }
                          term = term83;
                        }
                        if(cons8 == Simplify._consNeq_2)
                        { 
                          IStrategoTerm q_28 = null;
                          IStrategoTerm r_28 = null;
                          IStrategoTerm s_28 = null;
                          IStrategoTerm arg95 = term.getSubterm(0);
                          if(arg95.getTermType() != IStrategoTerm.APPL || Simplify._consSub_2 != ((IStrategoAppl)arg95).getConstructor())
                            break Fail65;
                          q_28 = arg95.getSubterm(0);
                          r_28 = arg95.getSubterm(1);
                          s_28 = term.getSubterm(1);
                          term = termFactory.makeAppl(Simplify._consNeq_2, new IStrategoTerm[]{q_28, termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{r_28, s_28})});
                        }
                        else
                        { 
                          break Fail65;
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class $Neg$Mul_0_0 extends Strategy 
  { 
    public static $Neg$Mul_0_0 instance = new $Neg$Mul_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      ITermFactory termFactory = context.getFactory();
      context.push("NegMul_0_0");
      Fail75:
      { 
        IStrategoTerm r_29 = null;
        IStrategoTerm s_29 = null;
        if(term.getTermType() != IStrategoTerm.APPL || Simplify._consNeg_1 != ((IStrategoAppl)term).getConstructor())
          break Fail75;
        IStrategoTerm arg96 = term.getSubterm(0);
        if(arg96.getTermType() != IStrategoTerm.APPL || Simplify._consMul_2 != ((IStrategoAppl)arg96).getConstructor())
          break Fail75;
        IStrategoTerm arg97 = arg96.getSubterm(0);
        if(arg97.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg97).getConstructor())
          break Fail75;
        s_29 = arg97.getSubterm(0);
        r_29 = arg96.getSubterm(1);
        term = termFactory.makeTuple(Simplify.const53, s_29);
        term = subt$S_0_0.instance.invoke(context, term);
        if(term == null)
          break Fail75;
        term = termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{term}), r_29});
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class $Remove$Mul1_0_0 extends Strategy 
  { 
    public static $Remove$Mul1_0_0 instance = new $Remove$Mul1_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      ITermFactory termFactory = context.getFactory();
      Fail76:
      { 
        IStrategoTerm term92 = term;
        IStrategoConstructor cons10 = term.getTermType() == IStrategoTerm.APPL ? ((IStrategoAppl)term).getConstructor() : null;
        Success59:
        { 
          if(cons10 == Simplify._consMul_2)
          { 
            Fail77:
            { 
              IStrategoTerm w_29 = null;
              IStrategoTerm arg98 = term.getSubterm(0);
              if(arg98.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg98).getConstructor())
                break Fail77;
              IStrategoTerm arg99 = arg98.getSubterm(0);
              if(arg99.getTermType() != IStrategoTerm.STRING || !"1".equals(((IStrategoString)arg99).stringValue()))
                break Fail77;
              w_29 = term.getSubterm(1);
              term = w_29;
              if(true)
                break Success59;
            }
            term = term92;
          }
          if(cons10 == Simplify._consMul_2)
          { 
            IStrategoTerm v_29 = null;
            IStrategoTerm arg100 = term.getSubterm(0);
            if(arg100.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg100).getConstructor())
              break Fail76;
            IStrategoTerm arg101 = arg100.getSubterm(0);
            if(arg101.getTermType() != IStrategoTerm.STRING || !"-1".equals(((IStrategoString)arg101).stringValue()))
              break Fail76;
            v_29 = term.getSubterm(1);
            term = termFactory.makeAppl(Simplify._consNeg_1, new IStrategoTerm[]{v_29});
          }
          else
          { 
            break Fail76;
          }
        }
        if(true)
          return term;
      }
      context.push("RemoveMul1_0_0");
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class debug_assertions_0_0 extends Strategy 
  { 
    public static debug_assertions_0_0 instance = new debug_assertions_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail78:
      { 
        if(true)
          return term;
      }
      context.push("debug_assertions_0_0");
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class try_assertion_0_0 extends Strategy 
  { 
    public static try_assertion_0_0 instance = new try_assertion_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      context.push("try_assertion_0_0");
      Fail79:
      { 
        term = try_1_0.instance.invoke(context, term, employ_assertion_0_0.instance);
        if(term == null)
          break Fail79;
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class define_assertion_0_1 extends Strategy 
  { 
    public static define_assertion_0_1 instance = new define_assertion_0_1();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term, IStrategoTerm ref_x_29)
    { 
      TermReference x_29 = new TermReference(ref_x_29);
      context.push("define_assertion_0_1");
      Fail80:
      { 
        lifted112 lifted1120 = new lifted112();
        lifted1120.x_29 = x_29;
        term = try_1_0.instance.invoke(context, term, lifted1120);
        if(term == null)
          break Fail80;
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class undefine_assertions_0_0 extends Strategy 
  { 
    public static undefine_assertions_0_0 instance = new undefine_assertions_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      ITermFactory termFactory = context.getFactory();
      context.push("undefine_assertions_0_0");
      Fail81:
      { 
        IStrategoTerm g_31 = null;
        IStrategoTerm h_31 = null;
        IStrategoTerm i_31 = null;
        IStrategoTerm j_31 = null;
        IStrategoTerm s_32 = null;
        IStrategoTerm u_32 = null;
        IStrategoTerm v_32 = null;
        h_31 = term;
        if(term.getTermType() != IStrategoTerm.APPL || Simplify._consVar_1 != ((IStrategoAppl)term).getConstructor())
          break Fail81;
        g_31 = term.getSubterm(0);
        i_31 = term;
        term = (IStrategoTerm)termFactory.makeListCons(Simplify.const63, termFactory.makeListCons(g_31, (IStrategoList)Simplify.constNil0));
        term = debug_assertions_0_0.instance.invoke(context, term);
        if(term == null)
          break Fail81;
        term = bagof_$Used$In$Assertion_0_0.instance.invoke(context, i_31);
        if(term == null)
          break Fail81;
        j_31 = term;
        u_32 = term;
        s_32 = Simplify.const64;
        v_32 = u_32;
        term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consVar_1, new IStrategoTerm[]{g_31}), checkListAnnos(termFactory, Simplify.constCons16));
        term = dr_undefine_rule_0_2.instance.invoke(context, v_32, s_32, term);
        if(term == null)
          break Fail81;
        term = map_1_0.instance.invoke(context, j_31, lifted113.instance);
        if(term == null)
          break Fail81;
        term = h_31;
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class get_vars_0_0 extends Strategy 
  { 
    public static get_vars_0_0 instance = new get_vars_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      context.push("get_vars_0_0");
      Fail82:
      { 
        term = collect_1_0.instance.invoke(context, term, lifted114.instance);
        if(term == null)
          break Fail82;
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class record_assertions_0_1 extends Strategy 
  { 
    public static record_assertions_0_1 instance = new record_assertions_0_1();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term, IStrategoTerm ref_x_37)
    { 
      TermReference x_37 = new TermReference(ref_x_37);
      context.push("record_assertions_0_1");
      Fail83:
      { 
        term = get_vars_0_0.instance.invoke(context, term);
        if(term == null)
          break Fail83;
        lifted115 lifted1150 = new lifted115();
        lifted1150.x_37 = x_37;
        term = map_1_0.instance.invoke(context, term, lifted1150);
        if(term == null)
          break Fail83;
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class employ_assertion_0_0 extends Strategy 
  { 
    public static employ_assertion_0_0 instance = new employ_assertion_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      context.push("employ_assertion_0_0");
      Fail84:
      { 
        IStrategoTerm term100 = term;
        Success60:
        { 
          Fail85:
          { 
            term = $Assertion1_0_0.instance.invoke(context, term);
            if(term == null)
              break Fail85;
            if(true)
              break Success60;
          }
          term = term100;
          IStrategoTerm term101 = term;
          Success61:
          { 
            Fail86:
            { 
              term = $Assertion2_0_0.instance.invoke(context, term);
              if(term == null)
                break Fail86;
              if(true)
                break Success61;
            }
            term = term101;
            IStrategoTerm term102 = term;
            Success62:
            { 
              Fail87:
              { 
                term = $Assertion3_0_0.instance.invoke(context, term);
                if(term == null)
                  break Fail87;
                if(true)
                  break Success62;
              }
              term = term102;
              IStrategoTerm term103 = term;
              Success63:
              { 
                Fail88:
                { 
                  term = $Assertion4_0_0.instance.invoke(context, term);
                  if(term == null)
                    break Fail88;
                  if(true)
                    break Success63;
                }
                term = term103;
                IStrategoTerm term104 = term;
                Success64:
                { 
                  Fail89:
                  { 
                    term = $Assertion5_0_0.instance.invoke(context, term);
                    if(term == null)
                      break Fail89;
                    if(true)
                      break Success64;
                  }
                  term = term104;
                  IStrategoTerm term105 = term;
                  Success65:
                  { 
                    Fail90:
                    { 
                      term = $Assertion6_0_0.instance.invoke(context, term);
                      if(term == null)
                        break Fail90;
                      if(true)
                        break Success65;
                    }
                    term = $Assertion7_0_0.instance.invoke(context, term105);
                    if(term == null)
                      break Fail84;
                  }
                }
              }
            }
          }
        }
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class define_assertion_gt_0_0 extends Strategy 
  { 
    public static define_assertion_gt_0_0 instance = new define_assertion_gt_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      ITermFactory termFactory = context.getFactory();
      context.push("define_assertion_gt_0_0");
      Fail91:
      { 
        TermReference m_38 = new TermReference();
        TermReference n_38 = new TermReference();
        IStrategoTerm o_38 = null;
        IStrategoTerm p_38 = null;
        IStrategoTerm y_38 = null;
        IStrategoTerm z_38 = null;
        IStrategoTerm b_39 = null;
        IStrategoTerm c_39 = null;
        IStrategoTerm d_39 = null;
        IStrategoTerm q_38 = null;
        IStrategoTerm e_39 = null;
        IStrategoTerm f_39 = null;
        IStrategoTerm h_39 = null;
        IStrategoTerm i_39 = null;
        IStrategoTerm j_39 = null;
        IStrategoTerm r_38 = null;
        IStrategoTerm k_39 = null;
        IStrategoTerm l_39 = null;
        IStrategoTerm n_39 = null;
        IStrategoTerm o_39 = null;
        IStrategoTerm p_39 = null;
        IStrategoTerm s_38 = null;
        IStrategoTerm q_39 = null;
        IStrategoTerm r_39 = null;
        IStrategoTerm t_39 = null;
        IStrategoTerm u_39 = null;
        IStrategoTerm v_39 = null;
        IStrategoTerm t_38 = null;
        IStrategoTerm w_39 = null;
        IStrategoTerm x_39 = null;
        IStrategoTerm z_39 = null;
        IStrategoTerm a_40 = null;
        IStrategoTerm b_40 = null;
        IStrategoTerm u_38 = null;
        IStrategoTerm c_40 = null;
        IStrategoTerm d_40 = null;
        IStrategoTerm f_40 = null;
        IStrategoTerm g_40 = null;
        IStrategoTerm h_40 = null;
        IStrategoTerm v_38 = null;
        lifted117 lifted1170 = new lifted117();
        lifted116 lifted1160 = new lifted116();
        lifted1170.m_38 = m_38;
        lifted1160.n_38 = n_38;
        term = $Gt_2_0.instance.invoke(context, term, lifted1160, lifted1170);
        if(term == null)
          break Fail91;
        o_38 = term;
        term = (IStrategoTerm)termFactory.makeListCons(Simplify.const66, termFactory.makeListCons(term, (IStrategoList)Simplify.constNil0));
        term = debug_assertions_0_0.instance.invoke(context, term);
        if(term == null)
          break Fail91;
        term = o_38;
        p_38 = o_38;
        b_39 = term;
        y_38 = Simplify.const57;
        term = b_39;
        c_39 = b_39;
        if(n_38.value == null)
          break Fail91;
        term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consGt_2, new IStrategoTerm[]{n_38.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
        z_38 = term;
        term = c_39;
        d_39 = c_39;
        if(m_38.value == null)
          break Fail91;
        term = termFactory.makeTuple(Simplify.const67, m_38.value);
        term = dr_add_rule_0_3.instance.invoke(context, d_39, y_38, z_38, term);
        if(term == null)
          break Fail91;
        term = p_38;
        q_38 = p_38;
        h_39 = term;
        e_39 = Simplify.const57;
        term = h_39;
        i_39 = h_39;
        if(n_38.value == null)
          break Fail91;
        term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consGeq_2, new IStrategoTerm[]{n_38.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
        f_39 = term;
        term = i_39;
        j_39 = i_39;
        if(m_38.value == null)
          break Fail91;
        term = termFactory.makeTuple(Simplify.const68, m_38.value);
        term = dr_add_rule_0_3.instance.invoke(context, j_39, e_39, f_39, term);
        if(term == null)
          break Fail91;
        term = q_38;
        r_38 = q_38;
        n_39 = term;
        k_39 = Simplify.const57;
        term = n_39;
        o_39 = n_39;
        if(n_38.value == null)
          break Fail91;
        term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consNeq_2, new IStrategoTerm[]{n_38.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
        l_39 = term;
        term = o_39;
        p_39 = o_39;
        if(m_38.value == null)
          break Fail91;
        term = termFactory.makeTuple(Simplify.const69, m_38.value);
        term = dr_add_rule_0_3.instance.invoke(context, p_39, k_39, l_39, term);
        if(term == null)
          break Fail91;
        term = r_38;
        s_38 = r_38;
        t_39 = term;
        q_39 = Simplify.const57;
        term = t_39;
        u_39 = t_39;
        if(n_38.value == null)
          break Fail91;
        term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consLt_2, new IStrategoTerm[]{n_38.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
        r_39 = term;
        term = u_39;
        v_39 = u_39;
        if(m_38.value == null)
          break Fail91;
        term = termFactory.makeTuple(Simplify.const70, m_38.value);
        term = dr_add_rule_0_3.instance.invoke(context, v_39, q_39, r_39, term);
        if(term == null)
          break Fail91;
        term = s_38;
        t_38 = s_38;
        z_39 = term;
        w_39 = Simplify.const57;
        term = z_39;
        a_40 = z_39;
        if(n_38.value == null)
          break Fail91;
        term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consLeq_2, new IStrategoTerm[]{n_38.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
        x_39 = term;
        term = a_40;
        b_40 = a_40;
        if(m_38.value == null)
          break Fail91;
        term = termFactory.makeTuple(Simplify.const71, m_38.value);
        term = dr_add_rule_0_3.instance.invoke(context, b_40, w_39, x_39, term);
        if(term == null)
          break Fail91;
        term = t_38;
        u_38 = t_38;
        f_40 = term;
        c_40 = Simplify.const57;
        term = f_40;
        g_40 = f_40;
        if(n_38.value == null)
          break Fail91;
        term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consEqu_2, new IStrategoTerm[]{n_38.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
        d_40 = term;
        term = g_40;
        h_40 = g_40;
        if(m_38.value == null)
          break Fail91;
        term = termFactory.makeTuple(Simplify.const72, m_38.value);
        term = dr_add_rule_0_3.instance.invoke(context, h_40, c_40, d_40, term);
        if(term == null)
          break Fail91;
        term = u_38;
        v_38 = u_38;
        if(n_38.value == null)
          break Fail91;
        term = record_assertions_0_1.instance.invoke(context, n_38.value, n_38.value);
        if(term == null)
          break Fail91;
        term = v_38;
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class define_assertion_geq_0_0 extends Strategy 
  { 
    public static define_assertion_geq_0_0 instance = new define_assertion_geq_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      ITermFactory termFactory = context.getFactory();
      context.push("define_assertion_geq_0_0");
      Fail92:
      { 
        IStrategoTerm o_40 = null;
        IStrategoTerm p_40 = null;
        IStrategoTerm q_40 = null;
        if(term.getTermType() != IStrategoTerm.APPL || Simplify._consGeq_2 != ((IStrategoAppl)term).getConstructor())
          break Fail92;
        p_40 = term.getSubterm(0);
        IStrategoTerm arg103 = term.getSubterm(1);
        if(arg103.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg103).getConstructor())
          break Fail92;
        o_40 = arg103.getSubterm(0);
        q_40 = term;
        term = (IStrategoTerm)termFactory.makeListCons(Simplify.const73, termFactory.makeListCons(term, (IStrategoList)Simplify.constNil0));
        term = debug_assertions_0_0.instance.invoke(context, term);
        if(term == null)
          break Fail92;
        term = q_40;
        IStrategoTerm term106 = term;
        Success66:
        { 
          Fail93:
          { 
            term = build_equality_assertion_geq_0_0.instance.invoke(context, term);
            if(term == null)
              break Fail93;
            if(true)
              break Success66;
          }
          term = term106;
          IStrategoTerm r_40 = null;
          IStrategoTerm a_41 = null;
          IStrategoTerm b_41 = null;
          IStrategoTerm d_41 = null;
          IStrategoTerm e_41 = null;
          IStrategoTerm f_41 = null;
          IStrategoTerm s_40 = null;
          IStrategoTerm g_41 = null;
          IStrategoTerm h_41 = null;
          IStrategoTerm j_41 = null;
          IStrategoTerm k_41 = null;
          IStrategoTerm l_41 = null;
          IStrategoTerm t_40 = null;
          IStrategoTerm m_41 = null;
          IStrategoTerm n_41 = null;
          IStrategoTerm p_41 = null;
          IStrategoTerm q_41 = null;
          IStrategoTerm r_41 = null;
          IStrategoTerm u_40 = null;
          IStrategoTerm s_41 = null;
          IStrategoTerm t_41 = null;
          IStrategoTerm v_41 = null;
          IStrategoTerm w_41 = null;
          IStrategoTerm x_41 = null;
          IStrategoTerm v_40 = null;
          IStrategoTerm y_41 = null;
          IStrategoTerm z_41 = null;
          IStrategoTerm b_42 = null;
          IStrategoTerm c_42 = null;
          IStrategoTerm d_42 = null;
          IStrategoTerm w_40 = null;
          IStrategoTerm e_42 = null;
          IStrategoTerm f_42 = null;
          IStrategoTerm h_42 = null;
          IStrategoTerm i_42 = null;
          IStrategoTerm j_42 = null;
          IStrategoTerm x_40 = null;
          r_40 = term;
          d_41 = term;
          a_41 = Simplify.const58;
          e_41 = d_41;
          term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consGt_2, new IStrategoTerm[]{p_40, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
          b_41 = term;
          f_41 = e_41;
          term = termFactory.makeTuple(Simplify.const74, o_40);
          term = dr_add_rule_0_3.instance.invoke(context, f_41, a_41, b_41, term);
          if(term == null)
            break Fail92;
          term = r_40;
          s_40 = r_40;
          j_41 = term;
          g_41 = Simplify.const58;
          k_41 = j_41;
          term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consGeq_2, new IStrategoTerm[]{p_40, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
          h_41 = term;
          l_41 = k_41;
          term = termFactory.makeTuple(Simplify.const75, o_40);
          term = dr_add_rule_0_3.instance.invoke(context, l_41, g_41, h_41, term);
          if(term == null)
            break Fail92;
          term = s_40;
          t_40 = s_40;
          p_41 = term;
          m_41 = Simplify.const58;
          q_41 = p_41;
          term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consNeq_2, new IStrategoTerm[]{p_40, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
          n_41 = term;
          r_41 = q_41;
          term = termFactory.makeTuple(Simplify.const76, o_40);
          term = dr_add_rule_0_3.instance.invoke(context, r_41, m_41, n_41, term);
          if(term == null)
            break Fail92;
          term = t_40;
          u_40 = t_40;
          v_41 = term;
          s_41 = Simplify.const58;
          w_41 = v_41;
          term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consLt_2, new IStrategoTerm[]{p_40, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
          t_41 = term;
          x_41 = w_41;
          term = termFactory.makeTuple(Simplify.const77, o_40);
          term = dr_add_rule_0_3.instance.invoke(context, x_41, s_41, t_41, term);
          if(term == null)
            break Fail92;
          term = u_40;
          v_40 = u_40;
          b_42 = term;
          y_41 = Simplify.const58;
          c_42 = b_42;
          term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consLeq_2, new IStrategoTerm[]{p_40, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
          z_41 = term;
          d_42 = c_42;
          term = termFactory.makeTuple(Simplify.const78, o_40);
          term = dr_add_rule_0_3.instance.invoke(context, d_42, y_41, z_41, term);
          if(term == null)
            break Fail92;
          term = v_40;
          w_40 = v_40;
          h_42 = term;
          e_42 = Simplify.const58;
          i_42 = h_42;
          term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consEqu_2, new IStrategoTerm[]{p_40, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
          f_42 = term;
          j_42 = i_42;
          term = termFactory.makeTuple(Simplify.const79, o_40);
          term = dr_add_rule_0_3.instance.invoke(context, j_42, e_42, f_42, term);
          if(term == null)
            break Fail92;
          x_40 = w_40;
          term = record_assertions_0_1.instance.invoke(context, p_40, p_40);
          if(term == null)
            break Fail92;
          term = x_40;
        }
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class build_equality_assertion_geq_0_0 extends Strategy 
  { 
    public static build_equality_assertion_geq_0_0 instance = new build_equality_assertion_geq_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      ITermFactory termFactory = context.getFactory();
      context.push("build_equality_assertion_geq_0_0");
      Fail94:
      { 
        IStrategoTerm k_42 = null;
        IStrategoTerm l_42 = null;
        IStrategoTerm m_42 = null;
        if(term.getTermType() != IStrategoTerm.APPL || Simplify._consGeq_2 != ((IStrategoAppl)term).getConstructor())
          break Fail94;
        k_42 = term.getSubterm(0);
        IStrategoTerm arg104 = term.getSubterm(1);
        if(arg104.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg104).getConstructor())
          break Fail94;
        l_42 = arg104.getSubterm(0);
        m_42 = term;
        term = termFactory.makeAppl(Simplify._consLeq_2, new IStrategoTerm[]{k_42, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{l_42})});
        term = employ_assertion_0_0.instance.invoke(context, term);
        if(term == null)
          break Fail94;
        if(term.getTermType() != IStrategoTerm.APPL || Simplify._consTrue_0 != ((IStrategoAppl)term).getConstructor())
          break Fail94;
        term = termFactory.makeAppl(Simplify._consEqu_2, new IStrategoTerm[]{k_42, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{l_42})});
        term = define_assertion_equ_0_0.instance.invoke(context, term);
        if(term == null)
          break Fail94;
        term = m_42;
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class define_assertion_leq_0_0 extends Strategy 
  { 
    public static define_assertion_leq_0_0 instance = new define_assertion_leq_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      ITermFactory termFactory = context.getFactory();
      context.push("define_assertion_leq_0_0");
      Fail95:
      { 
        TermReference t_42 = new TermReference();
        TermReference u_42 = new TermReference();
        IStrategoTerm v_42 = null;
        lifted120 lifted1200 = new lifted120();
        lifted119 lifted1190 = new lifted119();
        lifted1200.t_42 = t_42;
        lifted1190.u_42 = u_42;
        term = $Leq_2_0.instance.invoke(context, term, lifted1190, lifted1200);
        if(term == null)
          break Fail95;
        v_42 = term;
        term = (IStrategoTerm)termFactory.makeListCons(Simplify.const80, termFactory.makeListCons(term, (IStrategoList)Simplify.constNil0));
        term = debug_assertions_0_0.instance.invoke(context, term);
        if(term == null)
          break Fail95;
        term = v_42;
        IStrategoTerm term107 = term;
        Success67:
        { 
          Fail96:
          { 
            term = build_equality_assertion_leq_0_0.instance.invoke(context, term);
            if(term == null)
              break Fail96;
            if(true)
              break Success67;
          }
          term = term107;
          IStrategoTerm w_42 = null;
          IStrategoTerm f_43 = null;
          IStrategoTerm g_43 = null;
          IStrategoTerm i_43 = null;
          IStrategoTerm j_43 = null;
          IStrategoTerm k_43 = null;
          IStrategoTerm x_42 = null;
          IStrategoTerm l_43 = null;
          IStrategoTerm m_43 = null;
          IStrategoTerm o_43 = null;
          IStrategoTerm p_43 = null;
          IStrategoTerm q_43 = null;
          IStrategoTerm y_42 = null;
          IStrategoTerm r_43 = null;
          IStrategoTerm s_43 = null;
          IStrategoTerm u_43 = null;
          IStrategoTerm v_43 = null;
          IStrategoTerm w_43 = null;
          IStrategoTerm z_42 = null;
          IStrategoTerm x_43 = null;
          IStrategoTerm y_43 = null;
          IStrategoTerm a_44 = null;
          IStrategoTerm b_44 = null;
          IStrategoTerm c_44 = null;
          IStrategoTerm a_43 = null;
          IStrategoTerm d_44 = null;
          IStrategoTerm e_44 = null;
          IStrategoTerm g_44 = null;
          IStrategoTerm h_44 = null;
          IStrategoTerm i_44 = null;
          IStrategoTerm b_43 = null;
          IStrategoTerm j_44 = null;
          IStrategoTerm k_44 = null;
          IStrategoTerm m_44 = null;
          IStrategoTerm n_44 = null;
          IStrategoTerm o_44 = null;
          IStrategoTerm c_43 = null;
          w_42 = term;
          i_43 = term;
          f_43 = Simplify.const62;
          term = i_43;
          j_43 = i_43;
          if(u_42.value == null)
            break Fail95;
          term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consLt_2, new IStrategoTerm[]{u_42.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
          g_43 = term;
          term = j_43;
          k_43 = j_43;
          if(t_42.value == null)
            break Fail95;
          term = termFactory.makeTuple(Simplify.const81, t_42.value);
          term = dr_add_rule_0_3.instance.invoke(context, k_43, f_43, g_43, term);
          if(term == null)
            break Fail95;
          term = w_42;
          x_42 = w_42;
          o_43 = term;
          l_43 = Simplify.const62;
          term = o_43;
          p_43 = o_43;
          if(u_42.value == null)
            break Fail95;
          term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consLeq_2, new IStrategoTerm[]{u_42.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
          m_43 = term;
          term = p_43;
          q_43 = p_43;
          if(t_42.value == null)
            break Fail95;
          term = termFactory.makeTuple(Simplify.const82, t_42.value);
          term = dr_add_rule_0_3.instance.invoke(context, q_43, l_43, m_43, term);
          if(term == null)
            break Fail95;
          term = x_42;
          y_42 = x_42;
          u_43 = term;
          r_43 = Simplify.const62;
          term = u_43;
          v_43 = u_43;
          if(u_42.value == null)
            break Fail95;
          term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consNeq_2, new IStrategoTerm[]{u_42.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
          s_43 = term;
          term = v_43;
          w_43 = v_43;
          if(t_42.value == null)
            break Fail95;
          term = termFactory.makeTuple(Simplify.const83, t_42.value);
          term = dr_add_rule_0_3.instance.invoke(context, w_43, r_43, s_43, term);
          if(term == null)
            break Fail95;
          term = y_42;
          z_42 = y_42;
          a_44 = term;
          x_43 = Simplify.const62;
          term = a_44;
          b_44 = a_44;
          if(u_42.value == null)
            break Fail95;
          term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consGt_2, new IStrategoTerm[]{u_42.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
          y_43 = term;
          term = b_44;
          c_44 = b_44;
          if(t_42.value == null)
            break Fail95;
          term = termFactory.makeTuple(Simplify.const84, t_42.value);
          term = dr_add_rule_0_3.instance.invoke(context, c_44, x_43, y_43, term);
          if(term == null)
            break Fail95;
          term = z_42;
          a_43 = z_42;
          g_44 = term;
          d_44 = Simplify.const62;
          term = g_44;
          h_44 = g_44;
          if(u_42.value == null)
            break Fail95;
          term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consGeq_2, new IStrategoTerm[]{u_42.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
          e_44 = term;
          term = h_44;
          i_44 = h_44;
          if(t_42.value == null)
            break Fail95;
          term = termFactory.makeTuple(Simplify.const85, t_42.value);
          term = dr_add_rule_0_3.instance.invoke(context, i_44, d_44, e_44, term);
          if(term == null)
            break Fail95;
          term = a_43;
          b_43 = a_43;
          m_44 = term;
          j_44 = Simplify.const62;
          term = m_44;
          n_44 = m_44;
          if(u_42.value == null)
            break Fail95;
          term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consEqu_2, new IStrategoTerm[]{u_42.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
          k_44 = term;
          term = n_44;
          o_44 = n_44;
          if(t_42.value == null)
            break Fail95;
          term = termFactory.makeTuple(Simplify.const86, t_42.value);
          term = dr_add_rule_0_3.instance.invoke(context, o_44, j_44, k_44, term);
          if(term == null)
            break Fail95;
          term = b_43;
          c_43 = b_43;
          if(u_42.value == null)
            break Fail95;
          term = record_assertions_0_1.instance.invoke(context, u_42.value, u_42.value);
          if(term == null)
            break Fail95;
          term = c_43;
        }
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class build_equality_assertion_leq_0_0 extends Strategy 
  { 
    public static build_equality_assertion_leq_0_0 instance = new build_equality_assertion_leq_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      ITermFactory termFactory = context.getFactory();
      context.push("build_equality_assertion_leq_0_0");
      Fail97:
      { 
        IStrategoTerm p_44 = null;
        IStrategoTerm q_44 = null;
        IStrategoTerm r_44 = null;
        if(term.getTermType() != IStrategoTerm.APPL || Simplify._consLeq_2 != ((IStrategoAppl)term).getConstructor())
          break Fail97;
        p_44 = term.getSubterm(0);
        IStrategoTerm arg105 = term.getSubterm(1);
        if(arg105.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg105).getConstructor())
          break Fail97;
        q_44 = arg105.getSubterm(0);
        r_44 = term;
        term = termFactory.makeAppl(Simplify._consGeq_2, new IStrategoTerm[]{p_44, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{q_44})});
        term = employ_assertion_0_0.instance.invoke(context, term);
        if(term == null)
          break Fail97;
        if(term.getTermType() != IStrategoTerm.APPL || Simplify._consTrue_0 != ((IStrategoAppl)term).getConstructor())
          break Fail97;
        term = termFactory.makeAppl(Simplify._consEqu_2, new IStrategoTerm[]{p_44, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{q_44})});
        term = define_assertion_equ_0_0.instance.invoke(context, term);
        if(term == null)
          break Fail97;
        term = r_44;
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class define_assertion_lt_0_0 extends Strategy 
  { 
    public static define_assertion_lt_0_0 instance = new define_assertion_lt_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      ITermFactory termFactory = context.getFactory();
      context.push("define_assertion_lt_0_0");
      Fail98:
      { 
        TermReference y_44 = new TermReference();
        TermReference z_44 = new TermReference();
        IStrategoTerm a_45 = null;
        IStrategoTerm b_45 = null;
        IStrategoTerm k_45 = null;
        IStrategoTerm l_45 = null;
        IStrategoTerm n_45 = null;
        IStrategoTerm o_45 = null;
        IStrategoTerm p_45 = null;
        IStrategoTerm c_45 = null;
        IStrategoTerm q_45 = null;
        IStrategoTerm r_45 = null;
        IStrategoTerm t_45 = null;
        IStrategoTerm u_45 = null;
        IStrategoTerm v_45 = null;
        IStrategoTerm d_45 = null;
        IStrategoTerm w_45 = null;
        IStrategoTerm x_45 = null;
        IStrategoTerm z_45 = null;
        IStrategoTerm a_46 = null;
        IStrategoTerm b_46 = null;
        IStrategoTerm e_45 = null;
        IStrategoTerm c_46 = null;
        IStrategoTerm d_46 = null;
        IStrategoTerm f_46 = null;
        IStrategoTerm g_46 = null;
        IStrategoTerm h_46 = null;
        IStrategoTerm f_45 = null;
        IStrategoTerm i_46 = null;
        IStrategoTerm j_46 = null;
        IStrategoTerm l_46 = null;
        IStrategoTerm m_46 = null;
        IStrategoTerm n_46 = null;
        IStrategoTerm g_45 = null;
        IStrategoTerm o_46 = null;
        IStrategoTerm p_46 = null;
        IStrategoTerm r_46 = null;
        IStrategoTerm s_46 = null;
        IStrategoTerm t_46 = null;
        IStrategoTerm h_45 = null;
        lifted123 lifted1230 = new lifted123();
        lifted122 lifted1220 = new lifted122();
        lifted1230.y_44 = y_44;
        lifted1220.z_44 = z_44;
        term = $Lt_2_0.instance.invoke(context, term, lifted1220, lifted1230);
        if(term == null)
          break Fail98;
        a_45 = term;
        term = (IStrategoTerm)termFactory.makeListCons(Simplify.const87, termFactory.makeListCons(term, (IStrategoList)Simplify.constNil0));
        term = debug_assertions_0_0.instance.invoke(context, term);
        if(term == null)
          break Fail98;
        term = a_45;
        b_45 = a_45;
        n_45 = term;
        k_45 = Simplify.const55;
        term = n_45;
        o_45 = n_45;
        if(z_44.value == null)
          break Fail98;
        term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consLt_2, new IStrategoTerm[]{z_44.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
        l_45 = term;
        term = o_45;
        p_45 = o_45;
        if(y_44.value == null)
          break Fail98;
        term = termFactory.makeTuple(Simplify.const88, y_44.value);
        term = dr_add_rule_0_3.instance.invoke(context, p_45, k_45, l_45, term);
        if(term == null)
          break Fail98;
        term = b_45;
        c_45 = b_45;
        t_45 = term;
        q_45 = Simplify.const55;
        term = t_45;
        u_45 = t_45;
        if(z_44.value == null)
          break Fail98;
        term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consLeq_2, new IStrategoTerm[]{z_44.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
        r_45 = term;
        term = u_45;
        v_45 = u_45;
        if(y_44.value == null)
          break Fail98;
        term = termFactory.makeTuple(Simplify.const89, y_44.value);
        term = dr_add_rule_0_3.instance.invoke(context, v_45, q_45, r_45, term);
        if(term == null)
          break Fail98;
        term = c_45;
        d_45 = c_45;
        z_45 = term;
        w_45 = Simplify.const55;
        term = z_45;
        a_46 = z_45;
        if(z_44.value == null)
          break Fail98;
        term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consNeq_2, new IStrategoTerm[]{z_44.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
        x_45 = term;
        term = a_46;
        b_46 = a_46;
        if(y_44.value == null)
          break Fail98;
        term = termFactory.makeTuple(Simplify.const90, y_44.value);
        term = dr_add_rule_0_3.instance.invoke(context, b_46, w_45, x_45, term);
        if(term == null)
          break Fail98;
        term = d_45;
        e_45 = d_45;
        f_46 = term;
        c_46 = Simplify.const55;
        term = f_46;
        g_46 = f_46;
        if(z_44.value == null)
          break Fail98;
        term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consGt_2, new IStrategoTerm[]{z_44.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
        d_46 = term;
        term = g_46;
        h_46 = g_46;
        if(y_44.value == null)
          break Fail98;
        term = termFactory.makeTuple(Simplify.const91, y_44.value);
        term = dr_add_rule_0_3.instance.invoke(context, h_46, c_46, d_46, term);
        if(term == null)
          break Fail98;
        term = e_45;
        f_45 = e_45;
        l_46 = term;
        i_46 = Simplify.const55;
        term = l_46;
        m_46 = l_46;
        if(z_44.value == null)
          break Fail98;
        term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consGeq_2, new IStrategoTerm[]{z_44.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
        j_46 = term;
        term = m_46;
        n_46 = m_46;
        if(y_44.value == null)
          break Fail98;
        term = termFactory.makeTuple(Simplify.const92, y_44.value);
        term = dr_add_rule_0_3.instance.invoke(context, n_46, i_46, j_46, term);
        if(term == null)
          break Fail98;
        term = f_45;
        g_45 = f_45;
        r_46 = term;
        o_46 = Simplify.const55;
        term = r_46;
        s_46 = r_46;
        if(z_44.value == null)
          break Fail98;
        term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consEqu_2, new IStrategoTerm[]{z_44.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
        p_46 = term;
        term = s_46;
        t_46 = s_46;
        if(y_44.value == null)
          break Fail98;
        term = termFactory.makeTuple(Simplify.const93, y_44.value);
        term = dr_add_rule_0_3.instance.invoke(context, t_46, o_46, p_46, term);
        if(term == null)
          break Fail98;
        term = g_45;
        h_45 = g_45;
        if(z_44.value == null)
          break Fail98;
        term = record_assertions_0_1.instance.invoke(context, z_44.value, z_44.value);
        if(term == null)
          break Fail98;
        term = h_45;
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class define_assertion_neq_0_0 extends Strategy 
  { 
    public static define_assertion_neq_0_0 instance = new define_assertion_neq_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      ITermFactory termFactory = context.getFactory();
      context.push("define_assertion_neq_0_0");
      Fail99:
      { 
        TermReference w_46 = new TermReference();
        TermReference x_46 = new TermReference();
        IStrategoTerm y_46 = null;
        IStrategoTerm z_46 = null;
        IStrategoTerm e_47 = null;
        IStrategoTerm f_47 = null;
        IStrategoTerm h_47 = null;
        IStrategoTerm i_47 = null;
        IStrategoTerm j_47 = null;
        IStrategoTerm a_47 = null;
        IStrategoTerm k_47 = null;
        IStrategoTerm l_47 = null;
        IStrategoTerm n_47 = null;
        IStrategoTerm o_47 = null;
        IStrategoTerm p_47 = null;
        IStrategoTerm b_47 = null;
        lifted126 lifted1260 = new lifted126();
        lifted125 lifted1250 = new lifted125();
        lifted1260.w_46 = w_46;
        lifted1250.x_46 = x_46;
        term = $Neq_2_0.instance.invoke(context, term, lifted1250, lifted1260);
        if(term == null)
          break Fail99;
        y_46 = term;
        term = (IStrategoTerm)termFactory.makeListCons(Simplify.const94, termFactory.makeListCons(term, (IStrategoList)Simplify.constNil0));
        term = debug_assertions_0_0.instance.invoke(context, term);
        if(term == null)
          break Fail99;
        term = y_46;
        z_46 = y_46;
        h_47 = term;
        e_47 = Simplify.const59;
        term = h_47;
        i_47 = h_47;
        if(x_46.value == null)
          break Fail99;
        term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consNeq_2, new IStrategoTerm[]{x_46.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
        f_47 = term;
        term = i_47;
        j_47 = i_47;
        if(w_46.value == null)
          break Fail99;
        term = termFactory.makeTuple(Simplify.const95, w_46.value);
        term = dr_add_rule_0_3.instance.invoke(context, j_47, e_47, f_47, term);
        if(term == null)
          break Fail99;
        term = z_46;
        a_47 = z_46;
        n_47 = term;
        k_47 = Simplify.const59;
        term = n_47;
        o_47 = n_47;
        if(x_46.value == null)
          break Fail99;
        term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consEqu_2, new IStrategoTerm[]{x_46.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
        l_47 = term;
        term = o_47;
        p_47 = o_47;
        if(w_46.value == null)
          break Fail99;
        term = termFactory.makeTuple(Simplify.const96, w_46.value);
        term = dr_add_rule_0_3.instance.invoke(context, p_47, k_47, l_47, term);
        if(term == null)
          break Fail99;
        term = a_47;
        b_47 = a_47;
        if(x_46.value == null)
          break Fail99;
        term = record_assertions_0_1.instance.invoke(context, x_46.value, x_46.value);
        if(term == null)
          break Fail99;
        term = b_47;
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class define_assertion_equ_0_0 extends Strategy 
  { 
    public static define_assertion_equ_0_0 instance = new define_assertion_equ_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      ITermFactory termFactory = context.getFactory();
      context.push("define_assertion_equ_0_0");
      Fail100:
      { 
        TermReference x_47 = new TermReference();
        TermReference y_47 = new TermReference();
        IStrategoTerm z_47 = null;
        IStrategoTerm a_48 = null;
        IStrategoTerm k_48 = null;
        IStrategoTerm l_48 = null;
        IStrategoTerm n_48 = null;
        IStrategoTerm o_48 = null;
        IStrategoTerm p_48 = null;
        IStrategoTerm b_48 = null;
        IStrategoTerm q_48 = null;
        IStrategoTerm r_48 = null;
        IStrategoTerm t_48 = null;
        IStrategoTerm u_48 = null;
        IStrategoTerm v_48 = null;
        IStrategoTerm c_48 = null;
        IStrategoTerm w_48 = null;
        IStrategoTerm x_48 = null;
        IStrategoTerm z_48 = null;
        IStrategoTerm a_49 = null;
        IStrategoTerm b_49 = null;
        IStrategoTerm d_48 = null;
        IStrategoTerm c_49 = null;
        IStrategoTerm d_49 = null;
        IStrategoTerm f_49 = null;
        IStrategoTerm g_49 = null;
        IStrategoTerm h_49 = null;
        IStrategoTerm e_48 = null;
        IStrategoTerm i_49 = null;
        IStrategoTerm j_49 = null;
        IStrategoTerm l_49 = null;
        IStrategoTerm m_49 = null;
        IStrategoTerm n_49 = null;
        IStrategoTerm f_48 = null;
        IStrategoTerm o_49 = null;
        IStrategoTerm p_49 = null;
        IStrategoTerm r_49 = null;
        IStrategoTerm s_49 = null;
        IStrategoTerm t_49 = null;
        IStrategoTerm g_48 = null;
        IStrategoTerm u_49 = null;
        IStrategoTerm w_49 = null;
        IStrategoTerm x_49 = null;
        IStrategoTerm h_48 = null;
        lifted129 lifted1290 = new lifted129();
        lifted128 lifted1280 = new lifted128();
        lifted1290.x_47 = x_47;
        lifted1280.y_47 = y_47;
        term = $Equ_2_0.instance.invoke(context, term, lifted1280, lifted1290);
        if(term == null)
          break Fail100;
        z_47 = term;
        term = (IStrategoTerm)termFactory.makeListCons(Simplify.const97, termFactory.makeListCons(term, (IStrategoList)Simplify.constNil0));
        term = debug_assertions_0_0.instance.invoke(context, term);
        if(term == null)
          break Fail100;
        term = z_47;
        a_48 = z_47;
        n_48 = term;
        k_48 = Simplify.const60;
        term = n_48;
        o_48 = n_48;
        if(y_47.value == null)
          break Fail100;
        term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consLt_2, new IStrategoTerm[]{y_47.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
        l_48 = term;
        term = o_48;
        p_48 = o_48;
        if(x_47.value == null)
          break Fail100;
        term = termFactory.makeTuple(Simplify.const98, x_47.value);
        term = dr_add_rule_0_3.instance.invoke(context, p_48, k_48, l_48, term);
        if(term == null)
          break Fail100;
        term = a_48;
        b_48 = a_48;
        t_48 = term;
        q_48 = Simplify.const60;
        term = t_48;
        u_48 = t_48;
        if(y_47.value == null)
          break Fail100;
        term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consLeq_2, new IStrategoTerm[]{y_47.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
        r_48 = term;
        term = u_48;
        v_48 = u_48;
        if(x_47.value == null)
          break Fail100;
        term = termFactory.makeTuple(Simplify.const99, x_47.value);
        term = dr_add_rule_0_3.instance.invoke(context, v_48, q_48, r_48, term);
        if(term == null)
          break Fail100;
        term = b_48;
        c_48 = b_48;
        z_48 = term;
        w_48 = Simplify.const60;
        term = z_48;
        a_49 = z_48;
        if(y_47.value == null)
          break Fail100;
        term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consNeq_2, new IStrategoTerm[]{y_47.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
        x_48 = term;
        term = a_49;
        b_49 = a_49;
        if(x_47.value == null)
          break Fail100;
        term = termFactory.makeTuple(Simplify.const100, x_47.value);
        term = dr_add_rule_0_3.instance.invoke(context, b_49, w_48, x_48, term);
        if(term == null)
          break Fail100;
        term = c_48;
        d_48 = c_48;
        f_49 = term;
        c_49 = Simplify.const60;
        term = f_49;
        g_49 = f_49;
        if(y_47.value == null)
          break Fail100;
        term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consGt_2, new IStrategoTerm[]{y_47.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
        d_49 = term;
        term = g_49;
        h_49 = g_49;
        if(x_47.value == null)
          break Fail100;
        term = termFactory.makeTuple(Simplify.const101, x_47.value);
        term = dr_add_rule_0_3.instance.invoke(context, h_49, c_49, d_49, term);
        if(term == null)
          break Fail100;
        term = d_48;
        e_48 = d_48;
        l_49 = term;
        i_49 = Simplify.const60;
        term = l_49;
        m_49 = l_49;
        if(y_47.value == null)
          break Fail100;
        term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consGeq_2, new IStrategoTerm[]{y_47.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
        j_49 = term;
        term = m_49;
        n_49 = m_49;
        if(x_47.value == null)
          break Fail100;
        term = termFactory.makeTuple(Simplify.const102, x_47.value);
        term = dr_add_rule_0_3.instance.invoke(context, n_49, i_49, j_49, term);
        if(term == null)
          break Fail100;
        term = e_48;
        f_48 = e_48;
        r_49 = term;
        o_49 = Simplify.const60;
        term = r_49;
        s_49 = r_49;
        if(y_47.value == null)
          break Fail100;
        term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consEqu_2, new IStrategoTerm[]{y_47.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
        p_49 = term;
        term = s_49;
        t_49 = s_49;
        if(x_47.value == null)
          break Fail100;
        term = termFactory.makeTuple(Simplify.const103, x_47.value);
        term = dr_add_rule_0_3.instance.invoke(context, t_49, o_49, p_49, term);
        if(term == null)
          break Fail100;
        term = f_48;
        g_48 = f_48;
        w_49 = term;
        u_49 = Simplify.const61;
        term = w_49;
        x_49 = w_49;
        if(x_47.value == null)
          break Fail100;
        term = termFactory.makeTuple(Simplify.const104, x_47.value);
        term = dr_set_rule_0_3.instance.invoke(context, x_49, u_49, y_47.value, term);
        if(term == null)
          break Fail100;
        term = g_48;
        h_48 = g_48;
        if(y_47.value == null)
          break Fail100;
        term = record_assertions_0_1.instance.invoke(context, y_47.value, y_47.value);
        if(term == null)
          break Fail100;
        term = h_48;
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class define_assertion_false_0_1 extends Strategy 
  { 
    public static define_assertion_false_0_1 instance = new define_assertion_false_0_1();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term, IStrategoTerm y_49)
    { 
      context.push("define_assertion_false_0_1");
      Fail101:
      { 
        IStrategoTerm z_49 = null;
        if(term.getTermType() != IStrategoTerm.APPL || Simplify._consFalse_0 != ((IStrategoAppl)term).getConstructor())
          break Fail101;
        z_49 = term;
        term = debug_0_0.instance.invoke(context, Simplify.const105);
        if(term == null)
          break Fail101;
        term = debug_0_0.instance.invoke(context, y_49);
        if(term == null)
          break Fail101;
        term = z_49;
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class define_assertion_true_0_1 extends Strategy 
  { 
    public static define_assertion_true_0_1 instance = new define_assertion_true_0_1();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term, IStrategoTerm a_50)
    { 
      context.push("define_assertion_true_0_1");
      Fail102:
      { 
        IStrategoTerm b_50 = null;
        if(term.getTermType() != IStrategoTerm.APPL || Simplify._consTrue_0 != ((IStrategoAppl)term).getConstructor())
          break Fail102;
        b_50 = term;
        term = debug_assertions_0_0.instance.invoke(context, Simplify.const106);
        if(term == null)
          break Fail102;
        term = debug_assertions_0_0.instance.invoke(context, a_50);
        if(term == null)
          break Fail102;
        term = b_50;
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class minstring_0_0 extends Strategy 
  { 
    public static minstring_0_0 instance = new minstring_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      ITermFactory termFactory = context.getFactory();
      context.push("minstring_0_0");
      Fail103:
      { 
        IStrategoTerm d_50 = null;
        IStrategoTerm e_50 = null;
        if(term.getTermType() != IStrategoTerm.TUPLE || term.getSubtermCount() != 2)
          break Fail103;
        d_50 = term.getSubterm(0);
        e_50 = term.getSubterm(1);
        Success68:
        { 
          Fail104:
          { 
            IStrategoTerm f_50 = null;
            f_50 = term;
            term = termFactory.makeTuple(d_50, e_50);
            term = leq$S_0_0.instance.invoke(context, term);
            if(term == null)
              break Fail104;
            term = f_50;
            { 
              term = d_50;
              if(true)
                break Success68;
            }
          }
          term = e_50;
        }
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class maxstring_0_0 extends Strategy 
  { 
    public static maxstring_0_0 instance = new maxstring_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      ITermFactory termFactory = context.getFactory();
      context.push("maxstring_0_0");
      Fail105:
      { 
        IStrategoTerm g_50 = null;
        IStrategoTerm h_50 = null;
        if(term.getTermType() != IStrategoTerm.TUPLE || term.getSubtermCount() != 2)
          break Fail105;
        g_50 = term.getSubterm(0);
        h_50 = term.getSubterm(1);
        Success69:
        { 
          Fail106:
          { 
            IStrategoTerm i_50 = null;
            i_50 = term;
            term = termFactory.makeTuple(g_50, h_50);
            term = geq$S_0_0.instance.invoke(context, term);
            if(term == null)
              break Fail106;
            term = i_50;
            { 
              term = g_50;
              if(true)
                break Success69;
            }
          }
          term = h_50;
        }
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class normalise_0_0 extends Strategy 
  { 
    public static normalise_0_0 instance = new normalise_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      context.push("normalise_0_0");
      Fail107:
      { 
        term = canonical_0_0.instance.invoke(context, term);
        if(term == null)
          break Fail107;
        term = grouped_0_0.instance.invoke(context, term);
        if(term == null)
          break Fail107;
        term = eliminate_mul_1_0_0.instance.invoke(context, term);
        if(term == null)
          break Fail107;
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class canonical_0_0 extends Strategy 
  { 
    public static canonical_0_0 instance = new canonical_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      context.push("canonical_0_0");
      Fail108:
      { 
        t_480 t_4801 = new t_480();
        t_480 t_4800 = new t_480();
        t_4800.t_480 = t_4801;
        t_4801.t_480 = t_4801;
        term = s_480.instance.invoke(context, term, t_4800);
        if(term == null)
          break Fail108;
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class grouped_0_0 extends Strategy 
  { 
    public static grouped_0_0 instance = new grouped_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      context.push("grouped_0_0");
      Fail109:
      { 
        term = i_481.instance.invoke(context, term, j_481.instance);
        if(term == null)
          break Fail109;
        term = m_482.instance.invoke(context, term, n_482.instance);
        if(term == null)
          break Fail109;
        term = q_483.instance.invoke(context, term, r_483.instance);
        if(term == null)
          break Fail109;
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class z_483 extends Strategy 
  { 
    public static z_483 instance = new z_483();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      ITermFactory termFactory = context.getFactory();
      Fail110:
      { 
        IStrategoTerm term280 = term;
        Success70:
        { 
          Fail111:
          { 
            IStrategoTerm term281 = term;
            IStrategoConstructor cons11 = term.getTermType() == IStrategoTerm.APPL ? ((IStrategoAppl)term).getConstructor() : null;
            Success71:
            { 
              if(cons11 == Simplify._consMul_2)
              { 
                Fail112:
                { 
                  IStrategoTerm w_483 = null;
                  w_483 = term.getSubterm(0);
                  IStrategoTerm arg471 = term.getSubterm(1);
                  if(arg471.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg471).getConstructor())
                    break Fail112;
                  IStrategoTerm arg472 = arg471.getSubterm(0);
                  if(arg472.getTermType() != IStrategoTerm.STRING || !"1".equals(((IStrategoString)arg472).stringValue()))
                    break Fail112;
                  term = w_483;
                  if(true)
                    break Success71;
                }
                term = term281;
              }
              if(cons11 == Simplify._consMul_2)
              { 
                IStrategoTerm x_483 = null;
                x_483 = term.getSubterm(0);
                IStrategoTerm arg473 = term.getSubterm(1);
                if(arg473.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg473).getConstructor())
                  break Fail111;
                IStrategoTerm arg474 = arg473.getSubterm(0);
                if(arg474.getTermType() != IStrategoTerm.STRING || !"-1".equals(((IStrategoString)arg474).stringValue()))
                  break Fail111;
                term = termFactory.makeAppl(Simplify._consNeg_1, new IStrategoTerm[]{x_483});
              }
              else
              { 
                break Fail111;
              }
            }
            if(true)
              break Success70;
          }
          term = term280;
        }
        if(true)
          return term;
      }
      context.push("z_483");
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class eliminate_mul_1_0_0 extends Strategy 
  { 
    public static eliminate_mul_1_0_0 instance = new eliminate_mul_1_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      context.push("eliminate_mul_1_0_0");
      Fail113:
      { 
        term = y_483.instance.invoke(context, term, z_483.instance);
        if(term == null)
          break Fail113;
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class first_mul_0_0 extends Strategy 
  { 
    public static first_mul_0_0 instance = new first_mul_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      context.push("first_mul_0_0");
      Fail114:
      { 
        IStrategoTerm w_50 = null;
        IStrategoTerm y_50 = null;
        IStrategoTerm term282 = term;
        IStrategoConstructor cons12 = term.getTermType() == IStrategoTerm.APPL ? ((IStrategoAppl)term).getConstructor() : null;
        Success72:
        { 
          if(cons12 == Simplify._consAdd_2)
          { 
            Fail115:
            { 
              IStrategoTerm z_50 = null;
              z_50 = term;
              y_50 = term.getSubterm(0);
              term = z_50;
              { 
                term = this.invoke(context, y_50);
                if(term == null)
                  break Fail114;
                if(true)
                  break Success72;
              }
            }
            term = term282;
          }
          Success73:
          { 
            if(cons12 == Simplify._consMul_2)
            { 
              Fail116:
              { 
                IStrategoTerm a_51 = null;
                a_51 = term;
                IStrategoTerm arg475 = term.getSubterm(1);
                if(arg475.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg475).getConstructor())
                  break Fail116;
                w_50 = arg475.getSubterm(0);
                term = a_51;
                { 
                  term = w_50;
                  if(true)
                    break Success73;
                }
              }
              term = term282;
            }
            Success74:
            { 
              if(cons12 == Simplify._consDiv_2)
              { 
                Fail117:
                { 
                  IStrategoTerm b_51 = null;
                  b_51 = term;
                  y_50 = term.getSubterm(0);
                  term = b_51;
                  { 
                    term = this.invoke(context, y_50);
                    if(term == null)
                      break Fail114;
                    if(true)
                      break Success74;
                  }
                }
                term = term282;
              }
              term = Simplify.const54;
            }
          }
        }
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class $Push$Down$Not_0_0 extends Strategy 
  { 
    public static $Push$Down$Not_0_0 instance = new $Push$Down$Not_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      ITermFactory termFactory = context.getFactory();
      Fail118:
      { 
        IStrategoTerm term285 = term;
        IStrategoConstructor cons13 = term.getTermType() == IStrategoTerm.APPL ? ((IStrategoAppl)term).getConstructor() : null;
        Success75:
        { 
          if(cons13 == Simplify._consNot_1)
          { 
            Fail119:
            { 
              IStrategoTerm v_51 = null;
              IStrategoTerm w_51 = null;
              IStrategoTerm arg476 = term.getSubterm(0);
              if(arg476.getTermType() != IStrategoTerm.APPL || Simplify._consAnd_2 != ((IStrategoAppl)arg476).getConstructor())
                break Fail119;
              v_51 = arg476.getSubterm(0);
              w_51 = arg476.getSubterm(1);
              term = termFactory.makeAppl(Simplify._consOr_2, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consNot_1, new IStrategoTerm[]{v_51}), termFactory.makeAppl(Simplify._consNot_1, new IStrategoTerm[]{w_51})});
              if(true)
                break Success75;
            }
            term = term285;
          }
          Success76:
          { 
            if(cons13 == Simplify._consNot_1)
            { 
              Fail120:
              { 
                IStrategoTerm t_51 = null;
                IStrategoTerm u_51 = null;
                IStrategoTerm arg477 = term.getSubterm(0);
                if(arg477.getTermType() != IStrategoTerm.APPL || Simplify._consOr_2 != ((IStrategoAppl)arg477).getConstructor())
                  break Fail120;
                t_51 = arg477.getSubterm(0);
                u_51 = arg477.getSubterm(1);
                term = termFactory.makeAppl(Simplify._consAnd_2, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consNot_1, new IStrategoTerm[]{t_51}), termFactory.makeAppl(Simplify._consNot_1, new IStrategoTerm[]{u_51})});
                if(true)
                  break Success76;
              }
              term = term285;
            }
            Success77:
            { 
              if(cons13 == Simplify._consNot_1)
              { 
                Fail121:
                { 
                  IStrategoTerm r_51 = null;
                  IStrategoTerm s_51 = null;
                  IStrategoTerm arg478 = term.getSubterm(0);
                  if(arg478.getTermType() != IStrategoTerm.APPL || Simplify._consLt_2 != ((IStrategoAppl)arg478).getConstructor())
                    break Fail121;
                  r_51 = arg478.getSubterm(0);
                  s_51 = arg478.getSubterm(1);
                  term = termFactory.makeAppl(Simplify._consGeq_2, new IStrategoTerm[]{r_51, s_51});
                  if(true)
                    break Success77;
                }
                term = term285;
              }
              Success78:
              { 
                if(cons13 == Simplify._consNot_1)
                { 
                  Fail122:
                  { 
                    IStrategoTerm o_51 = null;
                    IStrategoTerm q_51 = null;
                    IStrategoTerm arg479 = term.getSubterm(0);
                    if(arg479.getTermType() != IStrategoTerm.APPL || Simplify._consLeq_2 != ((IStrategoAppl)arg479).getConstructor())
                      break Fail122;
                    o_51 = arg479.getSubterm(0);
                    q_51 = arg479.getSubterm(1);
                    term = termFactory.makeAppl(Simplify._consGt_2, new IStrategoTerm[]{o_51, q_51});
                    if(true)
                      break Success78;
                  }
                  term = term285;
                }
                Success79:
                { 
                  if(cons13 == Simplify._consNot_1)
                  { 
                    Fail123:
                    { 
                      IStrategoTerm m_51 = null;
                      IStrategoTerm n_51 = null;
                      IStrategoTerm arg480 = term.getSubterm(0);
                      if(arg480.getTermType() != IStrategoTerm.APPL || Simplify._consGt_2 != ((IStrategoAppl)arg480).getConstructor())
                        break Fail123;
                      m_51 = arg480.getSubterm(0);
                      n_51 = arg480.getSubterm(1);
                      term = termFactory.makeAppl(Simplify._consLeq_2, new IStrategoTerm[]{m_51, n_51});
                      if(true)
                        break Success79;
                    }
                    term = term285;
                  }
                  Success80:
                  { 
                    if(cons13 == Simplify._consNot_1)
                    { 
                      Fail124:
                      { 
                        IStrategoTerm h_51 = null;
                        IStrategoTerm k_51 = null;
                        IStrategoTerm arg481 = term.getSubterm(0);
                        if(arg481.getTermType() != IStrategoTerm.APPL || Simplify._consGeq_2 != ((IStrategoAppl)arg481).getConstructor())
                          break Fail124;
                        h_51 = arg481.getSubterm(0);
                        k_51 = arg481.getSubterm(1);
                        term = termFactory.makeAppl(Simplify._consLt_2, new IStrategoTerm[]{h_51, k_51});
                        if(true)
                          break Success80;
                      }
                      term = term285;
                    }
                    Success81:
                    { 
                      if(cons13 == Simplify._consNot_1)
                      { 
                        Fail125:
                        { 
                          IStrategoTerm e_51 = null;
                          IStrategoTerm g_51 = null;
                          IStrategoTerm arg482 = term.getSubterm(0);
                          if(arg482.getTermType() != IStrategoTerm.APPL || Simplify._consEqu_2 != ((IStrategoAppl)arg482).getConstructor())
                            break Fail125;
                          e_51 = arg482.getSubterm(0);
                          g_51 = arg482.getSubterm(1);
                          term = termFactory.makeAppl(Simplify._consNeq_2, new IStrategoTerm[]{e_51, g_51});
                          if(true)
                            break Success81;
                        }
                        term = term285;
                      }
                      if(cons13 == Simplify._consNot_1)
                      { 
                        IStrategoTerm c_51 = null;
                        IStrategoTerm d_51 = null;
                        IStrategoTerm arg483 = term.getSubterm(0);
                        if(arg483.getTermType() != IStrategoTerm.APPL || Simplify._consNeq_2 != ((IStrategoAppl)arg483).getConstructor())
                          break Fail118;
                        c_51 = arg483.getSubterm(0);
                        d_51 = arg483.getSubterm(1);
                        term = termFactory.makeAppl(Simplify._consEqu_2, new IStrategoTerm[]{c_51, d_51});
                      }
                      else
                      { 
                        break Fail118;
                      }
                    }
                  }
                }
              }
            }
          }
        }
        if(true)
          return term;
      }
      context.push("PushDownNot_0_0");
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class $Eliminate_0_0 extends Strategy 
  { 
    public static $Eliminate_0_0 instance = new $Eliminate_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      ITermFactory termFactory = context.getFactory();
      Fail126:
      { 
        IStrategoTerm term292 = term;
        IStrategoConstructor cons14 = term.getTermType() == IStrategoTerm.APPL ? ((IStrategoAppl)term).getConstructor() : null;
        Success82:
        { 
          if(cons14 == Simplify._consSub_2)
          { 
            Fail127:
            { 
              IStrategoTerm y_51 = null;
              IStrategoTerm z_51 = null;
              y_51 = term.getSubterm(0);
              z_51 = term.getSubterm(1);
              term = termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{y_51, termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{z_51, Simplify.constInt2})});
              if(true)
                break Success82;
            }
            term = term292;
          }
          if(cons14 == Simplify._consNeg_1)
          { 
            IStrategoTerm x_51 = null;
            x_51 = term.getSubterm(0);
            term = termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{x_51, Simplify.constInt2});
          }
          else
          { 
            break Fail126;
          }
        }
        if(true)
          return term;
      }
      context.push("Eliminate_0_0");
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class $Left$Group_0_0 extends Strategy 
  { 
    public static $Left$Group_0_0 instance = new $Left$Group_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      ITermFactory termFactory = context.getFactory();
      Fail128:
      { 
        IStrategoTerm term293 = term;
        IStrategoConstructor cons15 = term.getTermType() == IStrategoTerm.APPL ? ((IStrategoAppl)term).getConstructor() : null;
        Success83:
        { 
          if(cons15 == Simplify._consAdd_2)
          { 
            Fail129:
            { 
              IStrategoTerm m_52 = null;
              IStrategoTerm n_52 = null;
              IStrategoTerm o_52 = null;
              m_52 = term.getSubterm(0);
              IStrategoTerm arg484 = term.getSubterm(1);
              if(arg484.getTermType() != IStrategoTerm.APPL || Simplify._consAdd_2 != ((IStrategoAppl)arg484).getConstructor())
                break Fail129;
              n_52 = arg484.getSubterm(0);
              o_52 = arg484.getSubterm(1);
              term = termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{m_52, n_52}), o_52});
              if(true)
                break Success83;
            }
            term = term293;
          }
          Success84:
          { 
            if(cons15 == Simplify._consMul_2)
            { 
              Fail130:
              { 
                IStrategoTerm j_52 = null;
                IStrategoTerm k_52 = null;
                IStrategoTerm l_52 = null;
                j_52 = term.getSubterm(0);
                IStrategoTerm arg485 = term.getSubterm(1);
                if(arg485.getTermType() != IStrategoTerm.APPL || Simplify._consMul_2 != ((IStrategoAppl)arg485).getConstructor())
                  break Fail130;
                k_52 = arg485.getSubterm(0);
                l_52 = arg485.getSubterm(1);
                term = termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{j_52, k_52}), l_52});
                if(true)
                  break Success84;
              }
              term = term293;
            }
            Success85:
            { 
              if(cons15 == Simplify._consAnd_2)
              { 
                Fail131:
                { 
                  IStrategoTerm d_52 = null;
                  IStrategoTerm e_52 = null;
                  IStrategoTerm f_52 = null;
                  d_52 = term.getSubterm(0);
                  IStrategoTerm arg486 = term.getSubterm(1);
                  if(arg486.getTermType() != IStrategoTerm.APPL || Simplify._consAnd_2 != ((IStrategoAppl)arg486).getConstructor())
                    break Fail131;
                  e_52 = arg486.getSubterm(0);
                  f_52 = arg486.getSubterm(1);
                  term = termFactory.makeAppl(Simplify._consAnd_2, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consAnd_2, new IStrategoTerm[]{d_52, e_52}), f_52});
                  if(true)
                    break Success85;
                }
                term = term293;
              }
              if(cons15 == Simplify._consOr_2)
              { 
                IStrategoTerm a_52 = null;
                IStrategoTerm b_52 = null;
                IStrategoTerm c_52 = null;
                a_52 = term.getSubterm(0);
                IStrategoTerm arg487 = term.getSubterm(1);
                if(arg487.getTermType() != IStrategoTerm.APPL || Simplify._consOr_2 != ((IStrategoAppl)arg487).getConstructor())
                  break Fail128;
                b_52 = arg487.getSubterm(0);
                c_52 = arg487.getSubterm(1);
                term = termFactory.makeAppl(Simplify._consOr_2, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consOr_2, new IStrategoTerm[]{a_52, b_52}), c_52});
              }
              else
              { 
                break Fail128;
              }
            }
          }
        }
        if(true)
          return term;
      }
      context.push("LeftGroup_0_0");
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class $Sort$Expr_0_0 extends Strategy 
  { 
    public static $Sort$Expr_0_0 instance = new $Sort$Expr_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      ITermFactory termFactory = context.getFactory();
      context.push("SortExpr_0_0");
      Fail132:
      { 
        IStrategoTerm term296 = term;
        IStrategoConstructor cons16 = term.getTermType() == IStrategoTerm.APPL ? ((IStrategoAppl)term).getConstructor() : null;
        Success86:
        { 
          if(cons16 == Simplify._consAdd_2)
          { 
            Fail133:
            { 
              IStrategoTerm m_57 = null;
              IStrategoTerm n_57 = null;
              IStrategoTerm arg488 = term.getSubterm(0);
              if(arg488.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg488).getConstructor())
                break Fail133;
              n_57 = arg488.getSubterm(0);
              m_57 = term.getSubterm(1);
              term = termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{m_57, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{n_57})});
              if(true)
                break Success86;
            }
            term = term296;
          }
          Success87:
          { 
            if(cons16 == Simplify._consAdd_2)
            { 
              Fail134:
              { 
                IStrategoTerm j_57 = null;
                IStrategoTerm k_57 = null;
                IStrategoTerm l_57 = null;
                IStrategoTerm arg489 = term.getSubterm(0);
                if(arg489.getTermType() != IStrategoTerm.APPL || Simplify._consAdd_2 != ((IStrategoAppl)arg489).getConstructor())
                  break Fail134;
                j_57 = arg489.getSubterm(0);
                IStrategoTerm arg490 = arg489.getSubterm(1);
                if(arg490.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg490).getConstructor())
                  break Fail134;
                l_57 = arg490.getSubterm(0);
                k_57 = term.getSubterm(1);
                term = termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{j_57, k_57}), termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{l_57})});
                if(true)
                  break Success87;
              }
              term = term296;
            }
            Success88:
            { 
              if(cons16 == Simplify._consMul_2)
              { 
                Fail135:
                { 
                  IStrategoTerm h_57 = null;
                  IStrategoTerm i_57 = null;
                  IStrategoTerm arg491 = term.getSubterm(0);
                  if(arg491.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg491).getConstructor())
                    break Fail135;
                  i_57 = arg491.getSubterm(0);
                  h_57 = term.getSubterm(1);
                  term = termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{h_57, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{i_57})});
                  if(true)
                    break Success88;
                }
                term = term296;
              }
              Success89:
              { 
                if(cons16 == Simplify._consMul_2)
                { 
                  Fail136:
                  { 
                    IStrategoTerm e_57 = null;
                    IStrategoTerm f_57 = null;
                    IStrategoTerm g_57 = null;
                    IStrategoTerm arg492 = term.getSubterm(0);
                    if(arg492.getTermType() != IStrategoTerm.APPL || Simplify._consMul_2 != ((IStrategoAppl)arg492).getConstructor())
                      break Fail136;
                    e_57 = arg492.getSubterm(0);
                    IStrategoTerm arg493 = arg492.getSubterm(1);
                    if(arg493.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg493).getConstructor())
                      break Fail136;
                    g_57 = arg493.getSubterm(0);
                    f_57 = term.getSubterm(1);
                    term = termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{e_57, f_57}), termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{g_57})});
                    if(true)
                      break Success89;
                  }
                  term = term296;
                }
                Success90:
                { 
                  if(cons16 == Simplify._consDiv_2)
                  { 
                    Fail137:
                    { 
                      IStrategoTerm z_56 = null;
                      IStrategoTerm a_57 = null;
                      IStrategoTerm b_57 = null;
                      IStrategoTerm arg494 = term.getSubterm(0);
                      if(arg494.getTermType() != IStrategoTerm.APPL || Simplify._consDiv_2 != ((IStrategoAppl)arg494).getConstructor())
                        break Fail137;
                      z_56 = arg494.getSubterm(0);
                      IStrategoTerm arg495 = arg494.getSubterm(1);
                      if(arg495.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg495).getConstructor())
                        break Fail137;
                      b_57 = arg495.getSubterm(0);
                      a_57 = term.getSubterm(1);
                      term = termFactory.makeAppl(Simplify._consDiv_2, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consDiv_2, new IStrategoTerm[]{z_56, a_57}), termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{b_57})});
                      if(true)
                        break Success90;
                    }
                    term = term296;
                  }
                  Success91:
                  { 
                    if(cons16 == Simplify._consMul_2)
                    { 
                      Fail138:
                      { 
                        IStrategoTerm w_56 = null;
                        IStrategoTerm x_56 = null;
                        IStrategoTerm y_56 = null;
                        IStrategoTerm arg496 = term.getSubterm(0);
                        if(arg496.getTermType() != IStrategoTerm.APPL || Simplify._consAdd_2 != ((IStrategoAppl)arg496).getConstructor())
                          break Fail138;
                        w_56 = arg496.getSubterm(0);
                        x_56 = arg496.getSubterm(1);
                        IStrategoTerm arg497 = term.getSubterm(1);
                        if(arg497.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg497).getConstructor())
                          break Fail138;
                        y_56 = arg497.getSubterm(0);
                        term = termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{w_56, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{y_56})}), termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{x_56, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{y_56})})});
                        if(true)
                          break Success91;
                      }
                      term = term296;
                    }
                    Success92:
                    { 
                      if(cons16 == Simplify._consAdd_2)
                      { 
                        Fail139:
                        { 
                          IStrategoTerm s_56 = null;
                          IStrategoTerm t_56 = null;
                          IStrategoTerm u_56 = null;
                          IStrategoTerm arg498 = term.getSubterm(0);
                          if(arg498.getTermType() != IStrategoTerm.APPL || Simplify._consAdd_2 != ((IStrategoAppl)arg498).getConstructor())
                            break Fail139;
                          s_56 = arg498.getSubterm(0);
                          IStrategoTerm arg499 = arg498.getSubterm(1);
                          if(arg499.getTermType() != IStrategoTerm.APPL || Simplify._consVar_1 != ((IStrategoAppl)arg499).getConstructor())
                            break Fail139;
                          t_56 = arg499.getSubterm(0);
                          u_56 = term.getSubterm(1);
                          term = termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{s_56, termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consVar_1, new IStrategoTerm[]{t_56}), Simplify.constInt0})}), u_56});
                          if(true)
                            break Success92;
                        }
                        term = term296;
                      }
                      Success93:
                      { 
                        if(cons16 == Simplify._consAdd_2)
                        { 
                          Fail140:
                          { 
                            IStrategoTerm p_56 = null;
                            IStrategoTerm r_56 = null;
                            p_56 = term.getSubterm(0);
                            IStrategoTerm arg500 = term.getSubterm(1);
                            if(arg500.getTermType() != IStrategoTerm.APPL || Simplify._consVar_1 != ((IStrategoAppl)arg500).getConstructor())
                              break Fail140;
                            r_56 = arg500.getSubterm(0);
                            term = termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{p_56, termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consVar_1, new IStrategoTerm[]{r_56}), Simplify.constInt0})});
                            if(true)
                              break Success93;
                          }
                          term = term296;
                        }
                        Success94:
                        { 
                          if(cons16 == Simplify._consAdd_2)
                          { 
                            Fail141:
                            { 
                              IStrategoTerm d_56 = null;
                              IStrategoTerm j_56 = null;
                              IStrategoTerm o_56 = null;
                              j_56 = term.getSubterm(0);
                              d_56 = term.getSubterm(1);
                              term = j_56;
                              IStrategoTerm term305 = term;
                              Success95:
                              { 
                                Fail142:
                                { 
                                  if(term.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)term).getConstructor())
                                    break Fail142;
                                  { 
                                    if(true)
                                      break Fail141;
                                    if(true)
                                      break Success95;
                                  }
                                }
                                term = term305;
                              }
                              term = j_56;
                              IStrategoTerm term306 = term;
                              Success96:
                              { 
                                Fail143:
                                { 
                                  if(term.getTermType() != IStrategoTerm.APPL || Simplify._consMul_2 != ((IStrategoAppl)term).getConstructor())
                                    break Fail143;
                                  IStrategoTerm arg501 = term.getSubterm(1);
                                  if(arg501.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg501).getConstructor())
                                    break Fail143;
                                  { 
                                    if(true)
                                      break Fail141;
                                    if(true)
                                      break Success96;
                                  }
                                }
                                term = term306;
                              }
                              term = j_56;
                              IStrategoTerm term307 = term;
                              Success97:
                              { 
                                Fail144:
                                { 
                                  if(term.getTermType() != IStrategoTerm.APPL || Simplify._consAdd_2 != ((IStrategoAppl)term).getConstructor())
                                    break Fail144;
                                  { 
                                    if(true)
                                      break Fail141;
                                    if(true)
                                      break Success97;
                                  }
                                }
                                term = term307;
                              }
                              o_56 = term;
                              term = get_option_0_1.instance.invoke(context, o_56, Simplify.constMerge_complex_multiply0);
                              if(term == null)
                                break Fail141;
                              term = termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{j_56, Simplify.constInt0}), d_56});
                              if(true)
                                break Success94;
                            }
                            term = term296;
                          }
                          Success98:
                          { 
                            if(cons16 == Simplify._consAdd_2)
                            { 
                              Fail145:
                              { 
                                IStrategoTerm r_55 = null;
                                IStrategoTerm x_55 = null;
                                IStrategoTerm c_56 = null;
                                r_55 = term.getSubterm(0);
                                x_55 = term.getSubterm(1);
                                term = x_55;
                                IStrategoTerm term309 = term;
                                Success99:
                                { 
                                  Fail146:
                                  { 
                                    if(term.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)term).getConstructor())
                                      break Fail146;
                                    { 
                                      if(true)
                                        break Fail145;
                                      if(true)
                                        break Success99;
                                    }
                                  }
                                  term = term309;
                                }
                                term = x_55;
                                IStrategoTerm term310 = term;
                                Success100:
                                { 
                                  Fail147:
                                  { 
                                    if(term.getTermType() != IStrategoTerm.APPL || Simplify._consMul_2 != ((IStrategoAppl)term).getConstructor())
                                      break Fail147;
                                    IStrategoTerm arg502 = term.getSubterm(1);
                                    if(arg502.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg502).getConstructor())
                                      break Fail147;
                                    { 
                                      if(true)
                                        break Fail145;
                                      if(true)
                                        break Success100;
                                    }
                                  }
                                  term = term310;
                                }
                                term = x_55;
                                IStrategoTerm term311 = term;
                                Success101:
                                { 
                                  Fail148:
                                  { 
                                    if(term.getTermType() != IStrategoTerm.APPL || Simplify._consAdd_2 != ((IStrategoAppl)term).getConstructor())
                                      break Fail148;
                                    { 
                                      if(true)
                                        break Fail145;
                                      if(true)
                                        break Success101;
                                    }
                                  }
                                  term = term311;
                                }
                                c_56 = term;
                                term = get_option_0_1.instance.invoke(context, c_56, Simplify.constMerge_complex_multiply0);
                                if(term == null)
                                  break Fail145;
                                term = termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{r_55, termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{x_55, Simplify.constInt0})});
                                if(true)
                                  break Success98;
                              }
                              term = term296;
                            }
                            Success102:
                            { 
                              if(cons16 == Simplify._consLt_2)
                              { 
                                Fail149:
                                { 
                                  IStrategoTerm p_55 = null;
                                  IStrategoTerm q_55 = null;
                                  IStrategoTerm arg503 = term.getSubterm(0);
                                  if(arg503.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg503).getConstructor())
                                    break Fail149;
                                  q_55 = arg503.getSubterm(0);
                                  p_55 = term.getSubterm(1);
                                  term = termFactory.makeAppl(Simplify._consGt_2, new IStrategoTerm[]{p_55, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{q_55})});
                                  if(true)
                                    break Success102;
                                }
                                term = term296;
                              }
                              Success103:
                              { 
                                if(cons16 == Simplify._consLeq_2)
                                { 
                                  Fail150:
                                  { 
                                    IStrategoTerm n_55 = null;
                                    IStrategoTerm o_55 = null;
                                    IStrategoTerm arg504 = term.getSubterm(0);
                                    if(arg504.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg504).getConstructor())
                                      break Fail150;
                                    o_55 = arg504.getSubterm(0);
                                    n_55 = term.getSubterm(1);
                                    term = termFactory.makeAppl(Simplify._consGeq_2, new IStrategoTerm[]{n_55, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{o_55})});
                                    if(true)
                                      break Success103;
                                  }
                                  term = term296;
                                }
                                Success104:
                                { 
                                  if(cons16 == Simplify._consEqu_2)
                                  { 
                                    Fail151:
                                    { 
                                      IStrategoTerm j_55 = null;
                                      IStrategoTerm m_55 = null;
                                      IStrategoTerm arg505 = term.getSubterm(0);
                                      if(arg505.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg505).getConstructor())
                                        break Fail151;
                                      m_55 = arg505.getSubterm(0);
                                      j_55 = term.getSubterm(1);
                                      term = termFactory.makeAppl(Simplify._consEqu_2, new IStrategoTerm[]{j_55, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{m_55})});
                                      if(true)
                                        break Success104;
                                    }
                                    term = term296;
                                  }
                                  Success105:
                                  { 
                                    if(cons16 == Simplify._consGt_2)
                                    { 
                                      Fail152:
                                      { 
                                        IStrategoTerm h_55 = null;
                                        IStrategoTerm i_55 = null;
                                        IStrategoTerm arg506 = term.getSubterm(0);
                                        if(arg506.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg506).getConstructor())
                                          break Fail152;
                                        i_55 = arg506.getSubterm(0);
                                        h_55 = term.getSubterm(1);
                                        term = termFactory.makeAppl(Simplify._consLt_2, new IStrategoTerm[]{h_55, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{i_55})});
                                        if(true)
                                          break Success105;
                                      }
                                      term = term296;
                                    }
                                    Success106:
                                    { 
                                      if(cons16 == Simplify._consGeq_2)
                                      { 
                                        Fail153:
                                        { 
                                          IStrategoTerm f_55 = null;
                                          IStrategoTerm g_55 = null;
                                          IStrategoTerm arg507 = term.getSubterm(0);
                                          if(arg507.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg507).getConstructor())
                                            break Fail153;
                                          g_55 = arg507.getSubterm(0);
                                          f_55 = term.getSubterm(1);
                                          term = termFactory.makeAppl(Simplify._consLeq_2, new IStrategoTerm[]{f_55, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{g_55})});
                                          if(true)
                                            break Success106;
                                        }
                                        term = term296;
                                      }
                                      Success107:
                                      { 
                                        if(cons16 == Simplify._consNeq_2)
                                        { 
                                          Fail154:
                                          { 
                                            IStrategoTerm d_55 = null;
                                            IStrategoTerm e_55 = null;
                                            IStrategoTerm arg508 = term.getSubterm(0);
                                            if(arg508.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg508).getConstructor())
                                              break Fail154;
                                            e_55 = arg508.getSubterm(0);
                                            d_55 = term.getSubterm(1);
                                            term = termFactory.makeAppl(Simplify._consNeq_2, new IStrategoTerm[]{d_55, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{e_55})});
                                            if(true)
                                              break Success107;
                                          }
                                          term = term296;
                                        }
                                        Success108:
                                        { 
                                          if(cons16 == Simplify._consLt_2)
                                          { 
                                            Fail155:
                                            { 
                                              IStrategoTerm y_54 = null;
                                              IStrategoTerm z_54 = null;
                                              IStrategoTerm c_55 = null;
                                              IStrategoTerm arg509 = term.getSubterm(0);
                                              if(arg509.getTermType() != IStrategoTerm.APPL || Simplify._consAdd_2 != ((IStrategoAppl)arg509).getConstructor())
                                                break Fail155;
                                              y_54 = arg509.getSubterm(0);
                                              IStrategoTerm arg510 = arg509.getSubterm(1);
                                              if(arg510.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg510).getConstructor())
                                                break Fail155;
                                              c_55 = arg510.getSubterm(0);
                                              z_54 = term.getSubterm(1);
                                              term = termFactory.makeAppl(Simplify._consLt_2, new IStrategoTerm[]{y_54, termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{z_54, termFactory.makeAppl(Simplify._consNeg_1, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{c_55})})})});
                                              if(true)
                                                break Success108;
                                            }
                                            term = term296;
                                          }
                                          Success109:
                                          { 
                                            if(cons16 == Simplify._consLeq_2)
                                            { 
                                              Fail156:
                                              { 
                                                IStrategoTerm v_54 = null;
                                                IStrategoTerm w_54 = null;
                                                IStrategoTerm x_54 = null;
                                                IStrategoTerm arg511 = term.getSubterm(0);
                                                if(arg511.getTermType() != IStrategoTerm.APPL || Simplify._consAdd_2 != ((IStrategoAppl)arg511).getConstructor())
                                                  break Fail156;
                                                v_54 = arg511.getSubterm(0);
                                                IStrategoTerm arg512 = arg511.getSubterm(1);
                                                if(arg512.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg512).getConstructor())
                                                  break Fail156;
                                                x_54 = arg512.getSubterm(0);
                                                w_54 = term.getSubterm(1);
                                                term = termFactory.makeAppl(Simplify._consLeq_2, new IStrategoTerm[]{v_54, termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{w_54, termFactory.makeAppl(Simplify._consNeg_1, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{x_54})})})});
                                                if(true)
                                                  break Success109;
                                              }
                                              term = term296;
                                            }
                                            Success110:
                                            { 
                                              if(cons16 == Simplify._consEqu_2)
                                              { 
                                                Fail157:
                                                { 
                                                  IStrategoTerm s_54 = null;
                                                  IStrategoTerm t_54 = null;
                                                  IStrategoTerm u_54 = null;
                                                  IStrategoTerm arg513 = term.getSubterm(0);
                                                  if(arg513.getTermType() != IStrategoTerm.APPL || Simplify._consAdd_2 != ((IStrategoAppl)arg513).getConstructor())
                                                    break Fail157;
                                                  s_54 = arg513.getSubterm(0);
                                                  IStrategoTerm arg514 = arg513.getSubterm(1);
                                                  if(arg514.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg514).getConstructor())
                                                    break Fail157;
                                                  u_54 = arg514.getSubterm(0);
                                                  t_54 = term.getSubterm(1);
                                                  term = termFactory.makeAppl(Simplify._consEqu_2, new IStrategoTerm[]{s_54, termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{t_54, termFactory.makeAppl(Simplify._consNeg_1, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{u_54})})})});
                                                  if(true)
                                                    break Success110;
                                                }
                                                term = term296;
                                              }
                                              Success111:
                                              { 
                                                if(cons16 == Simplify._consGt_2)
                                                { 
                                                  Fail158:
                                                  { 
                                                    IStrategoTerm n_54 = null;
                                                    IStrategoTerm o_54 = null;
                                                    IStrategoTerm r_54 = null;
                                                    IStrategoTerm arg515 = term.getSubterm(0);
                                                    if(arg515.getTermType() != IStrategoTerm.APPL || Simplify._consAdd_2 != ((IStrategoAppl)arg515).getConstructor())
                                                      break Fail158;
                                                    n_54 = arg515.getSubterm(0);
                                                    IStrategoTerm arg516 = arg515.getSubterm(1);
                                                    if(arg516.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg516).getConstructor())
                                                      break Fail158;
                                                    r_54 = arg516.getSubterm(0);
                                                    o_54 = term.getSubterm(1);
                                                    term = termFactory.makeAppl(Simplify._consGt_2, new IStrategoTerm[]{n_54, termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{o_54, termFactory.makeAppl(Simplify._consNeg_1, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{r_54})})})});
                                                    if(true)
                                                      break Success111;
                                                  }
                                                  term = term296;
                                                }
                                                Success112:
                                                { 
                                                  if(cons16 == Simplify._consGeq_2)
                                                  { 
                                                    Fail159:
                                                    { 
                                                      IStrategoTerm k_54 = null;
                                                      IStrategoTerm l_54 = null;
                                                      IStrategoTerm m_54 = null;
                                                      IStrategoTerm arg517 = term.getSubterm(0);
                                                      if(arg517.getTermType() != IStrategoTerm.APPL || Simplify._consAdd_2 != ((IStrategoAppl)arg517).getConstructor())
                                                        break Fail159;
                                                      k_54 = arg517.getSubterm(0);
                                                      IStrategoTerm arg518 = arg517.getSubterm(1);
                                                      if(arg518.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg518).getConstructor())
                                                        break Fail159;
                                                      m_54 = arg518.getSubterm(0);
                                                      l_54 = term.getSubterm(1);
                                                      term = termFactory.makeAppl(Simplify._consGeq_2, new IStrategoTerm[]{k_54, termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{l_54, termFactory.makeAppl(Simplify._consNeg_1, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{m_54})})})});
                                                      if(true)
                                                        break Success112;
                                                    }
                                                    term = term296;
                                                  }
                                                  Success113:
                                                  { 
                                                    if(cons16 == Simplify._consNeq_2)
                                                    { 
                                                      Fail160:
                                                      { 
                                                        IStrategoTerm h_54 = null;
                                                        IStrategoTerm i_54 = null;
                                                        IStrategoTerm j_54 = null;
                                                        IStrategoTerm arg519 = term.getSubterm(0);
                                                        if(arg519.getTermType() != IStrategoTerm.APPL || Simplify._consAdd_2 != ((IStrategoAppl)arg519).getConstructor())
                                                          break Fail160;
                                                        h_54 = arg519.getSubterm(0);
                                                        IStrategoTerm arg520 = arg519.getSubterm(1);
                                                        if(arg520.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg520).getConstructor())
                                                          break Fail160;
                                                        j_54 = arg520.getSubterm(0);
                                                        i_54 = term.getSubterm(1);
                                                        term = termFactory.makeAppl(Simplify._consNeq_2, new IStrategoTerm[]{h_54, termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{i_54, termFactory.makeAppl(Simplify._consNeg_1, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{j_54})})})});
                                                        if(true)
                                                          break Success113;
                                                      }
                                                      term = term296;
                                                    }
                                                    Success114:
                                                    { 
                                                      if(cons16 == Simplify._consLt_2)
                                                      { 
                                                        Fail161:
                                                        { 
                                                          IStrategoTerm c_54 = null;
                                                          IStrategoTerm d_54 = null;
                                                          IStrategoTerm e_54 = null;
                                                          c_54 = term.getSubterm(0);
                                                          IStrategoTerm arg521 = term.getSubterm(1);
                                                          if(arg521.getTermType() != IStrategoTerm.APPL || Simplify._consAdd_2 != ((IStrategoAppl)arg521).getConstructor())
                                                            break Fail161;
                                                          d_54 = arg521.getSubterm(0);
                                                          e_54 = arg521.getSubterm(1);
                                                          term = termFactory.makeAppl(Simplify._consLt_2, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{c_54, termFactory.makeAppl(Simplify._consNeg_1, new IStrategoTerm[]{d_54})}), e_54});
                                                          if(true)
                                                            break Success114;
                                                        }
                                                        term = term296;
                                                      }
                                                      Success115:
                                                      { 
                                                        if(cons16 == Simplify._consLeq_2)
                                                        { 
                                                          Fail162:
                                                          { 
                                                            IStrategoTerm z_53 = null;
                                                            IStrategoTerm a_54 = null;
                                                            IStrategoTerm b_54 = null;
                                                            z_53 = term.getSubterm(0);
                                                            IStrategoTerm arg522 = term.getSubterm(1);
                                                            if(arg522.getTermType() != IStrategoTerm.APPL || Simplify._consAdd_2 != ((IStrategoAppl)arg522).getConstructor())
                                                              break Fail162;
                                                            a_54 = arg522.getSubterm(0);
                                                            b_54 = arg522.getSubterm(1);
                                                            term = termFactory.makeAppl(Simplify._consLeq_2, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{z_53, termFactory.makeAppl(Simplify._consNeg_1, new IStrategoTerm[]{a_54})}), b_54});
                                                            if(true)
                                                              break Success115;
                                                          }
                                                          term = term296;
                                                        }
                                                        Success116:
                                                        { 
                                                          if(cons16 == Simplify._consEqu_2)
                                                          { 
                                                            Fail163:
                                                            { 
                                                              IStrategoTerm w_53 = null;
                                                              IStrategoTerm x_53 = null;
                                                              IStrategoTerm y_53 = null;
                                                              w_53 = term.getSubterm(0);
                                                              IStrategoTerm arg523 = term.getSubterm(1);
                                                              if(arg523.getTermType() != IStrategoTerm.APPL || Simplify._consAdd_2 != ((IStrategoAppl)arg523).getConstructor())
                                                                break Fail163;
                                                              x_53 = arg523.getSubterm(0);
                                                              y_53 = arg523.getSubterm(1);
                                                              term = termFactory.makeAppl(Simplify._consEqu_2, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{w_53, termFactory.makeAppl(Simplify._consNeg_1, new IStrategoTerm[]{x_53})}), y_53});
                                                              if(true)
                                                                break Success116;
                                                            }
                                                            term = term296;
                                                          }
                                                          Success117:
                                                          { 
                                                            if(cons16 == Simplify._consGt_2)
                                                            { 
                                                              Fail164:
                                                              { 
                                                                IStrategoTerm t_53 = null;
                                                                IStrategoTerm u_53 = null;
                                                                IStrategoTerm v_53 = null;
                                                                t_53 = term.getSubterm(0);
                                                                IStrategoTerm arg524 = term.getSubterm(1);
                                                                if(arg524.getTermType() != IStrategoTerm.APPL || Simplify._consAdd_2 != ((IStrategoAppl)arg524).getConstructor())
                                                                  break Fail164;
                                                                u_53 = arg524.getSubterm(0);
                                                                v_53 = arg524.getSubterm(1);
                                                                term = termFactory.makeAppl(Simplify._consGt_2, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{t_53, termFactory.makeAppl(Simplify._consNeg_1, new IStrategoTerm[]{u_53})}), v_53});
                                                                if(true)
                                                                  break Success117;
                                                              }
                                                              term = term296;
                                                            }
                                                            Success118:
                                                            { 
                                                              if(cons16 == Simplify._consGeq_2)
                                                              { 
                                                                Fail165:
                                                                { 
                                                                  IStrategoTerm q_53 = null;
                                                                  IStrategoTerm r_53 = null;
                                                                  IStrategoTerm s_53 = null;
                                                                  q_53 = term.getSubterm(0);
                                                                  IStrategoTerm arg525 = term.getSubterm(1);
                                                                  if(arg525.getTermType() != IStrategoTerm.APPL || Simplify._consAdd_2 != ((IStrategoAppl)arg525).getConstructor())
                                                                    break Fail165;
                                                                  r_53 = arg525.getSubterm(0);
                                                                  s_53 = arg525.getSubterm(1);
                                                                  term = termFactory.makeAppl(Simplify._consGeq_2, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{q_53, termFactory.makeAppl(Simplify._consNeg_1, new IStrategoTerm[]{r_53})}), s_53});
                                                                  if(true)
                                                                    break Success118;
                                                                }
                                                                term = term296;
                                                              }
                                                              Success119:
                                                              { 
                                                                if(cons16 == Simplify._consNeq_2)
                                                                { 
                                                                  Fail166:
                                                                  { 
                                                                    IStrategoTerm n_53 = null;
                                                                    IStrategoTerm o_53 = null;
                                                                    IStrategoTerm p_53 = null;
                                                                    n_53 = term.getSubterm(0);
                                                                    IStrategoTerm arg526 = term.getSubterm(1);
                                                                    if(arg526.getTermType() != IStrategoTerm.APPL || Simplify._consAdd_2 != ((IStrategoAppl)arg526).getConstructor())
                                                                      break Fail166;
                                                                    o_53 = arg526.getSubterm(0);
                                                                    p_53 = arg526.getSubterm(1);
                                                                    term = termFactory.makeAppl(Simplify._consNeq_2, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{n_53, termFactory.makeAppl(Simplify._consNeg_1, new IStrategoTerm[]{o_53})}), p_53});
                                                                    if(true)
                                                                      break Success119;
                                                                  }
                                                                  term = term296;
                                                                }
                                                                Success120:
                                                                { 
                                                                  if(cons16 == Simplify._consLt_2)
                                                                  { 
                                                                    Fail167:
                                                                    { 
                                                                      IStrategoTerm j_53 = null;
                                                                      IStrategoTerm k_53 = null;
                                                                      j_53 = term.getSubterm(0);
                                                                      k_53 = term.getSubterm(1);
                                                                      term = k_53;
                                                                      IStrategoTerm term331 = term;
                                                                      Success121:
                                                                      { 
                                                                        Fail168:
                                                                        { 
                                                                          if(term.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)term).getConstructor())
                                                                            break Fail168;
                                                                          { 
                                                                            if(true)
                                                                              break Fail167;
                                                                            if(true)
                                                                              break Success121;
                                                                          }
                                                                        }
                                                                        term = term331;
                                                                      }
                                                                      term = termFactory.makeAppl(Simplify._consLt_2, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{j_53, termFactory.makeAppl(Simplify._consNeg_1, new IStrategoTerm[]{k_53})}), Simplify.constInt3});
                                                                      if(true)
                                                                        break Success120;
                                                                    }
                                                                    term = term296;
                                                                  }
                                                                  Success122:
                                                                  { 
                                                                    if(cons16 == Simplify._consLeq_2)
                                                                    { 
                                                                      Fail169:
                                                                      { 
                                                                        IStrategoTerm f_53 = null;
                                                                        IStrategoTerm g_53 = null;
                                                                        f_53 = term.getSubterm(0);
                                                                        g_53 = term.getSubterm(1);
                                                                        term = g_53;
                                                                        IStrategoTerm term333 = term;
                                                                        Success123:
                                                                        { 
                                                                          Fail170:
                                                                          { 
                                                                            if(term.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)term).getConstructor())
                                                                              break Fail170;
                                                                            { 
                                                                              if(true)
                                                                                break Fail169;
                                                                              if(true)
                                                                                break Success123;
                                                                            }
                                                                          }
                                                                          term = term333;
                                                                        }
                                                                        term = termFactory.makeAppl(Simplify._consLeq_2, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{f_53, termFactory.makeAppl(Simplify._consNeg_1, new IStrategoTerm[]{g_53})}), Simplify.constInt3});
                                                                        if(true)
                                                                          break Success122;
                                                                      }
                                                                      term = term296;
                                                                    }
                                                                    Success124:
                                                                    { 
                                                                      if(cons16 == Simplify._consEqu_2)
                                                                      { 
                                                                        Fail171:
                                                                        { 
                                                                          IStrategoTerm b_53 = null;
                                                                          IStrategoTerm c_53 = null;
                                                                          b_53 = term.getSubterm(0);
                                                                          c_53 = term.getSubterm(1);
                                                                          term = c_53;
                                                                          IStrategoTerm term335 = term;
                                                                          Success125:
                                                                          { 
                                                                            Fail172:
                                                                            { 
                                                                              if(term.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)term).getConstructor())
                                                                                break Fail172;
                                                                              { 
                                                                                if(true)
                                                                                  break Fail171;
                                                                                if(true)
                                                                                  break Success125;
                                                                              }
                                                                            }
                                                                            term = term335;
                                                                          }
                                                                          term = termFactory.makeAppl(Simplify._consEqu_2, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{b_53, termFactory.makeAppl(Simplify._consNeg_1, new IStrategoTerm[]{c_53})}), Simplify.constInt3});
                                                                          if(true)
                                                                            break Success124;
                                                                        }
                                                                        term = term296;
                                                                      }
                                                                      Success126:
                                                                      { 
                                                                        if(cons16 == Simplify._consGt_2)
                                                                        { 
                                                                          Fail173:
                                                                          { 
                                                                            IStrategoTerm x_52 = null;
                                                                            IStrategoTerm y_52 = null;
                                                                            x_52 = term.getSubterm(0);
                                                                            y_52 = term.getSubterm(1);
                                                                            term = y_52;
                                                                            IStrategoTerm term337 = term;
                                                                            Success127:
                                                                            { 
                                                                              Fail174:
                                                                              { 
                                                                                if(term.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)term).getConstructor())
                                                                                  break Fail174;
                                                                                { 
                                                                                  if(true)
                                                                                    break Fail173;
                                                                                  if(true)
                                                                                    break Success127;
                                                                                }
                                                                              }
                                                                              term = term337;
                                                                            }
                                                                            term = termFactory.makeAppl(Simplify._consGt_2, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{x_52, termFactory.makeAppl(Simplify._consNeg_1, new IStrategoTerm[]{y_52})}), Simplify.constInt3});
                                                                            if(true)
                                                                              break Success126;
                                                                          }
                                                                          term = term296;
                                                                        }
                                                                        Success128:
                                                                        { 
                                                                          if(cons16 == Simplify._consGeq_2)
                                                                          { 
                                                                            Fail175:
                                                                            { 
                                                                              IStrategoTerm t_52 = null;
                                                                              IStrategoTerm u_52 = null;
                                                                              t_52 = term.getSubterm(0);
                                                                              u_52 = term.getSubterm(1);
                                                                              term = u_52;
                                                                              IStrategoTerm term339 = term;
                                                                              Success129:
                                                                              { 
                                                                                Fail176:
                                                                                { 
                                                                                  if(term.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)term).getConstructor())
                                                                                    break Fail176;
                                                                                  { 
                                                                                    if(true)
                                                                                      break Fail175;
                                                                                    if(true)
                                                                                      break Success129;
                                                                                  }
                                                                                }
                                                                                term = term339;
                                                                              }
                                                                              term = termFactory.makeAppl(Simplify._consGeq_2, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{t_52, termFactory.makeAppl(Simplify._consNeg_1, new IStrategoTerm[]{u_52})}), Simplify.constInt3});
                                                                              if(true)
                                                                                break Success128;
                                                                            }
                                                                            term = term296;
                                                                          }
                                                                          if(cons16 == Simplify._consNeq_2)
                                                                          { 
                                                                            IStrategoTerm p_52 = null;
                                                                            IStrategoTerm q_52 = null;
                                                                            p_52 = term.getSubterm(0);
                                                                            q_52 = term.getSubterm(1);
                                                                            term = q_52;
                                                                            IStrategoTerm term340 = term;
                                                                            Success130:
                                                                            { 
                                                                              Fail177:
                                                                              { 
                                                                                if(term.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)term).getConstructor())
                                                                                  break Fail177;
                                                                                { 
                                                                                  if(true)
                                                                                    break Fail132;
                                                                                  if(true)
                                                                                    break Success130;
                                                                                }
                                                                              }
                                                                              term = term340;
                                                                            }
                                                                            term = termFactory.makeAppl(Simplify._consNeq_2, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{p_52, termFactory.makeAppl(Simplify._consNeg_1, new IStrategoTerm[]{q_52})}), Simplify.constInt3});
                                                                          }
                                                                          else
                                                                          { 
                                                                            break Fail132;
                                                                          }
                                                                        }
                                                                      }
                                                                    }
                                                                  }
                                                                }
                                                              }
                                                            }
                                                          }
                                                        }
                                                      }
                                                    }
                                                  }
                                                }
                                              }
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class $Normalise$Compare_0_0 extends Strategy 
  { 
    public static $Normalise$Compare_0_0 instance = new $Normalise$Compare_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      ITermFactory termFactory = context.getFactory();
      context.push("NormaliseCompare_0_0");
      Fail178:
      { 
        IStrategoTerm term341 = term;
        IStrategoConstructor cons29 = term.getTermType() == IStrategoTerm.APPL ? ((IStrategoAppl)term).getConstructor() : null;
        Success131:
        { 
          if(cons29 == Simplify._consNeq_2)
          { 
            Fail179:
            { 
              IStrategoTerm p_58 = null;
              IStrategoTerm q_58 = null;
              q_58 = term.getSubterm(0);
              IStrategoTerm arg527 = term.getSubterm(1);
              if(arg527.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg527).getConstructor())
                break Fail179;
              p_58 = arg527.getSubterm(0);
              term = first_mul_0_0.instance.invoke(context, q_58);
              if(term == null)
                break Fail179;
              term = termFactory.makeTuple(term, Simplify.const53);
              term = lt$S_0_0.instance.invoke(context, term);
              if(term == null)
                break Fail179;
              term = termFactory.makeAppl(Simplify._consNeq_2, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{q_58, Simplify.constInt2}), termFactory.makeAppl(Simplify._consNeg_1, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{p_58})})});
              if(true)
                break Success131;
            }
            term = term341;
          }
          Success132:
          { 
            if(cons29 == Simplify._consEqu_2)
            { 
              Fail180:
              { 
                IStrategoTerm i_58 = null;
                IStrategoTerm j_58 = null;
                j_58 = term.getSubterm(0);
                IStrategoTerm arg528 = term.getSubterm(1);
                if(arg528.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg528).getConstructor())
                  break Fail180;
                i_58 = arg528.getSubterm(0);
                term = first_mul_0_0.instance.invoke(context, j_58);
                if(term == null)
                  break Fail180;
                term = termFactory.makeTuple(term, Simplify.const53);
                term = lt$S_0_0.instance.invoke(context, term);
                if(term == null)
                  break Fail180;
                term = termFactory.makeAppl(Simplify._consEqu_2, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{j_58, Simplify.constInt2}), termFactory.makeAppl(Simplify._consNeg_1, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{i_58})})});
                if(true)
                  break Success132;
              }
              term = term341;
            }
            Success133:
            { 
              if(cons29 == Simplify._consLt_2)
              { 
                Fail181:
                { 
                  IStrategoTerm c_58 = null;
                  IStrategoTerm d_58 = null;
                  d_58 = term.getSubterm(0);
                  IStrategoTerm arg529 = term.getSubterm(1);
                  if(arg529.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg529).getConstructor())
                    break Fail181;
                  c_58 = arg529.getSubterm(0);
                  term = first_mul_0_0.instance.invoke(context, d_58);
                  if(term == null)
                    break Fail181;
                  term = termFactory.makeTuple(term, Simplify.const53);
                  term = lt$S_0_0.instance.invoke(context, term);
                  if(term == null)
                    break Fail181;
                  term = termFactory.makeAppl(Simplify._consGt_2, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{d_58, Simplify.constInt2}), termFactory.makeAppl(Simplify._consNeg_1, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{c_58})})});
                  if(true)
                    break Success133;
                }
                term = term341;
              }
              Success134:
              { 
                if(cons29 == Simplify._consLeq_2)
                { 
                  Fail182:
                  { 
                    IStrategoTerm w_57 = null;
                    IStrategoTerm x_57 = null;
                    x_57 = term.getSubterm(0);
                    IStrategoTerm arg530 = term.getSubterm(1);
                    if(arg530.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg530).getConstructor())
                      break Fail182;
                    w_57 = arg530.getSubterm(0);
                    term = first_mul_0_0.instance.invoke(context, x_57);
                    if(term == null)
                      break Fail182;
                    term = termFactory.makeTuple(term, Simplify.const53);
                    term = lt$S_0_0.instance.invoke(context, term);
                    if(term == null)
                      break Fail182;
                    term = termFactory.makeAppl(Simplify._consGeq_2, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{x_57, Simplify.constInt2}), termFactory.makeAppl(Simplify._consNeg_1, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{w_57})})});
                    if(true)
                      break Success134;
                  }
                  term = term341;
                }
                Success135:
                { 
                  if(cons29 == Simplify._consGt_2)
                  { 
                    Fail183:
                    { 
                      IStrategoTerm s_57 = null;
                      IStrategoTerm t_57 = null;
                      t_57 = term.getSubterm(0);
                      IStrategoTerm arg531 = term.getSubterm(1);
                      if(arg531.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg531).getConstructor())
                        break Fail183;
                      s_57 = arg531.getSubterm(0);
                      term = first_mul_0_0.instance.invoke(context, t_57);
                      if(term == null)
                        break Fail183;
                      term = termFactory.makeTuple(term, Simplify.const53);
                      term = lt$S_0_0.instance.invoke(context, term);
                      if(term == null)
                        break Fail183;
                      term = termFactory.makeAppl(Simplify._consLt_2, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{t_57, Simplify.constInt2}), termFactory.makeAppl(Simplify._consNeg_1, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{s_57})})});
                      if(true)
                        break Success135;
                    }
                    term = term341;
                  }
                  if(cons29 == Simplify._consGeq_2)
                  { 
                    IStrategoTerm o_57 = null;
                    IStrategoTerm p_57 = null;
                    p_57 = term.getSubterm(0);
                    IStrategoTerm arg532 = term.getSubterm(1);
                    if(arg532.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg532).getConstructor())
                      break Fail178;
                    o_57 = arg532.getSubterm(0);
                    term = first_mul_0_0.instance.invoke(context, p_57);
                    if(term == null)
                      break Fail178;
                    term = termFactory.makeTuple(term, Simplify.const53);
                    term = lt$S_0_0.instance.invoke(context, term);
                    if(term == null)
                      break Fail178;
                    term = termFactory.makeAppl(Simplify._consLeq_2, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{p_57, Simplify.constInt2}), termFactory.makeAppl(Simplify._consNeg_1, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{o_57})})});
                  }
                  else
                  { 
                    break Fail178;
                  }
                }
              }
            }
          }
        }
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class variable_name_reorder_0_0 extends Strategy 
  { 
    public static variable_name_reorder_0_0 instance = new variable_name_reorder_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      context.push("variable_name_reorder_0_0");
      Fail184:
      { 
        IStrategoTerm term346 = term;
        Success136:
        { 
          Fail185:
          { 
            IStrategoTerm u_58 = null;
            u_58 = term;
            if(term.getTermType() != IStrategoTerm.TUPLE || term.getSubtermCount() != 2)
              break Fail185;
            IStrategoTerm arg534 = term.getSubterm(1);
            if(arg534.getTermType() != IStrategoTerm.STRING || !"row".equals(((IStrategoString)arg534).stringValue()))
              break Fail185;
            term = u_58;
            if(true)
              break Success136;
          }
          term = term346;
          IStrategoTerm term347 = term;
          Success137:
          { 
            Fail186:
            { 
              IStrategoTerm v_58 = null;
              v_58 = term;
              if(term.getTermType() != IStrategoTerm.TUPLE || term.getSubtermCount() != 2)
                break Fail186;
              IStrategoTerm arg535 = term.getSubterm(0);
              if(arg535.getTermType() != IStrategoTerm.STRING || !"row".equals(((IStrategoString)arg535).stringValue()))
                break Fail186;
              term = v_58;
              { 
                if(true)
                  break Fail184;
                if(true)
                  break Success137;
              }
            }
            term = term347;
            IStrategoTerm term348 = term;
            Success138:
            { 
              Fail187:
              { 
                IStrategoTerm y_58 = null;
                y_58 = term;
                if(term.getTermType() != IStrategoTerm.TUPLE || term.getSubtermCount() != 2)
                  break Fail187;
                IStrategoTerm arg538 = term.getSubterm(1);
                if(arg538.getTermType() != IStrategoTerm.STRING || !"column".equals(((IStrategoString)arg538).stringValue()))
                  break Fail187;
                term = y_58;
                if(true)
                  break Success138;
              }
              term = term348;
              IStrategoTerm term349 = term;
              Success139:
              { 
                Fail188:
                { 
                  IStrategoTerm z_58 = null;
                  z_58 = term;
                  if(term.getTermType() != IStrategoTerm.TUPLE || term.getSubtermCount() != 2)
                    break Fail188;
                  IStrategoTerm arg539 = term.getSubterm(0);
                  if(arg539.getTermType() != IStrategoTerm.STRING || !"column".equals(((IStrategoString)arg539).stringValue()))
                    break Fail188;
                  term = z_58;
                  { 
                    if(true)
                      break Fail184;
                    if(true)
                      break Success139;
                  }
                }
                term = string_gt_0_0.instance.invoke(context, term349);
                if(term == null)
                  break Fail184;
              }
            }
          }
        }
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class $Sort$Terms_0_0 extends Strategy 
  { 
    public static $Sort$Terms_0_0 instance = new $Sort$Terms_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      ITermFactory termFactory = context.getFactory();
      context.push("SortTerms_0_0");
      Fail189:
      { 
        IStrategoTerm term350 = term;
        IStrategoConstructor cons30 = term.getTermType() == IStrategoTerm.APPL ? ((IStrategoAppl)term).getConstructor() : null;
        Success140:
        { 
          if(cons30 == Simplify._consAdd_2)
          { 
            Fail190:
            { 
              IStrategoTerm n_59 = null;
              IStrategoTerm o_59 = null;
              IStrategoTerm p_59 = null;
              IStrategoTerm q_59 = null;
              IStrategoTerm arg541 = term.getSubterm(0);
              if(arg541.getTermType() != IStrategoTerm.APPL || Simplify._consMul_2 != ((IStrategoAppl)arg541).getConstructor())
                break Fail190;
              IStrategoTerm arg542 = arg541.getSubterm(0);
              if(arg542.getTermType() != IStrategoTerm.APPL || Simplify._consVar_1 != ((IStrategoAppl)arg542).getConstructor())
                break Fail190;
              p_59 = arg542.getSubterm(0);
              IStrategoTerm arg543 = arg541.getSubterm(1);
              if(arg543.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg543).getConstructor())
                break Fail190;
              o_59 = arg543.getSubterm(0);
              IStrategoTerm arg544 = term.getSubterm(1);
              if(arg544.getTermType() != IStrategoTerm.APPL || Simplify._consMul_2 != ((IStrategoAppl)arg544).getConstructor())
                break Fail190;
              IStrategoTerm arg545 = arg544.getSubterm(0);
              if(arg545.getTermType() != IStrategoTerm.APPL || Simplify._consVar_1 != ((IStrategoAppl)arg545).getConstructor())
                break Fail190;
              q_59 = arg545.getSubterm(0);
              IStrategoTerm arg546 = arg544.getSubterm(1);
              if(arg546.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg546).getConstructor())
                break Fail190;
              n_59 = arg546.getSubterm(0);
              term = termFactory.makeTuple(p_59, q_59);
              term = variable_name_reorder_0_0.instance.invoke(context, term);
              if(term == null)
                break Fail190;
              term = termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consVar_1, new IStrategoTerm[]{q_59}), termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{n_59})}), termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consVar_1, new IStrategoTerm[]{p_59}), termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{o_59})})});
              if(true)
                break Success140;
            }
            term = term350;
          }
          Success141:
          { 
            if(cons30 == Simplify._consAdd_2)
            { 
              Fail191:
              { 
                IStrategoTerm h_59 = null;
                IStrategoTerm i_59 = null;
                IStrategoTerm j_59 = null;
                IStrategoTerm k_59 = null;
                IStrategoTerm l_59 = null;
                IStrategoTerm arg547 = term.getSubterm(0);
                if(arg547.getTermType() != IStrategoTerm.APPL || Simplify._consAdd_2 != ((IStrategoAppl)arg547).getConstructor())
                  break Fail191;
                h_59 = arg547.getSubterm(0);
                IStrategoTerm arg548 = arg547.getSubterm(1);
                if(arg548.getTermType() != IStrategoTerm.APPL || Simplify._consMul_2 != ((IStrategoAppl)arg548).getConstructor())
                  break Fail191;
                IStrategoTerm arg549 = arg548.getSubterm(0);
                if(arg549.getTermType() != IStrategoTerm.APPL || Simplify._consVar_1 != ((IStrategoAppl)arg549).getConstructor())
                  break Fail191;
                k_59 = arg549.getSubterm(0);
                IStrategoTerm arg550 = arg548.getSubterm(1);
                if(arg550.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg550).getConstructor())
                  break Fail191;
                j_59 = arg550.getSubterm(0);
                IStrategoTerm arg551 = term.getSubterm(1);
                if(arg551.getTermType() != IStrategoTerm.APPL || Simplify._consMul_2 != ((IStrategoAppl)arg551).getConstructor())
                  break Fail191;
                IStrategoTerm arg552 = arg551.getSubterm(0);
                if(arg552.getTermType() != IStrategoTerm.APPL || Simplify._consVar_1 != ((IStrategoAppl)arg552).getConstructor())
                  break Fail191;
                l_59 = arg552.getSubterm(0);
                IStrategoTerm arg553 = arg551.getSubterm(1);
                if(arg553.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg553).getConstructor())
                  break Fail191;
                i_59 = arg553.getSubterm(0);
                term = termFactory.makeTuple(k_59, l_59);
                term = variable_name_reorder_0_0.instance.invoke(context, term);
                if(term == null)
                  break Fail191;
                term = termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{h_59, termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consVar_1, new IStrategoTerm[]{l_59}), termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{i_59})})}), termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consVar_1, new IStrategoTerm[]{k_59}), termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{j_59})})});
                if(true)
                  break Success141;
              }
              term = term350;
            }
            Success142:
            { 
              if(cons30 == Simplify._consAdd_2)
              { 
                Fail192:
                { 
                  IStrategoTerm e_59 = null;
                  IStrategoTerm f_59 = null;
                  e_59 = term.getSubterm(0);
                  f_59 = term.getSubterm(1);
                  term = e_59;
                  IStrategoTerm term353 = term;
                  Success143:
                  { 
                    Fail193:
                    { 
                      if(term.getTermType() != IStrategoTerm.APPL || Simplify._consAdd_2 != ((IStrategoAppl)term).getConstructor())
                        break Fail193;
                      { 
                        if(true)
                          break Fail192;
                        if(true)
                          break Success143;
                      }
                    }
                    term = term353;
                  }
                  term = e_59;
                  IStrategoTerm term354 = term;
                  Success144:
                  { 
                    Fail194:
                    { 
                      if(term.getTermType() != IStrategoTerm.APPL || Simplify._consMul_2 != ((IStrategoAppl)term).getConstructor())
                        break Fail194;
                      IStrategoTerm arg556 = term.getSubterm(0);
                      if(arg556.getTermType() != IStrategoTerm.APPL || Simplify._consVar_1 != ((IStrategoAppl)arg556).getConstructor())
                        break Fail194;
                      IStrategoTerm arg558 = term.getSubterm(1);
                      if(arg558.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg558).getConstructor())
                        break Fail194;
                      { 
                        if(true)
                          break Fail192;
                        if(true)
                          break Success144;
                      }
                    }
                    term = term354;
                  }
                  term = f_59;
                  if(term.getTermType() != IStrategoTerm.APPL || Simplify._consMul_2 != ((IStrategoAppl)term).getConstructor())
                    break Fail192;
                  IStrategoTerm arg560 = term.getSubterm(0);
                  if(arg560.getTermType() != IStrategoTerm.APPL || Simplify._consVar_1 != ((IStrategoAppl)arg560).getConstructor())
                    break Fail192;
                  IStrategoTerm arg562 = term.getSubterm(1);
                  if(arg562.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg562).getConstructor())
                    break Fail192;
                  term = termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{f_59, e_59});
                  if(true)
                    break Success142;
                }
                term = term350;
              }
              if(cons30 == Simplify._consAdd_2)
              { 
                IStrategoTerm a_59 = null;
                IStrategoTerm b_59 = null;
                IStrategoTerm c_59 = null;
                IStrategoTerm arg564 = term.getSubterm(0);
                if(arg564.getTermType() != IStrategoTerm.APPL || Simplify._consAdd_2 != ((IStrategoAppl)arg564).getConstructor())
                  break Fail189;
                a_59 = arg564.getSubterm(0);
                b_59 = arg564.getSubterm(1);
                c_59 = term.getSubterm(1);
                term = b_59;
                IStrategoTerm term355 = term;
                Success145:
                { 
                  Fail195:
                  { 
                    if(term.getTermType() != IStrategoTerm.APPL || Simplify._consMul_2 != ((IStrategoAppl)term).getConstructor())
                      break Fail195;
                    IStrategoTerm arg565 = term.getSubterm(0);
                    if(arg565.getTermType() != IStrategoTerm.APPL || Simplify._consVar_1 != ((IStrategoAppl)arg565).getConstructor())
                      break Fail195;
                    IStrategoTerm arg567 = term.getSubterm(1);
                    if(arg567.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg567).getConstructor())
                      break Fail195;
                    { 
                      if(true)
                        break Fail189;
                      if(true)
                        break Success145;
                    }
                  }
                  term = term355;
                }
                term = c_59;
                if(term.getTermType() != IStrategoTerm.APPL || Simplify._consMul_2 != ((IStrategoAppl)term).getConstructor())
                  break Fail189;
                IStrategoTerm arg569 = term.getSubterm(0);
                if(arg569.getTermType() != IStrategoTerm.APPL || Simplify._consVar_1 != ((IStrategoAppl)arg569).getConstructor())
                  break Fail189;
                IStrategoTerm arg571 = term.getSubterm(1);
                if(arg571.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg571).getConstructor())
                  break Fail189;
                term = termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{a_59, c_59}), b_59});
              }
              else
              { 
                break Fail189;
              }
            }
          }
        }
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class comparison_reorder_0_0 extends Strategy 
  { 
    public static comparison_reorder_0_0 instance = new comparison_reorder_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      context.push("comparison_reorder_0_0");
      Fail196:
      { 
        term = comparison_reorder_code_0_0.instance.invoke(context, term);
        if(term == null)
          break Fail196;
        if(term.getTermType() != IStrategoTerm.APPL || Simplify._consTrue_0 != ((IStrategoAppl)term).getConstructor())
          break Fail196;
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class comparison_reorder_code_0_0 extends Strategy 
  { 
    public static comparison_reorder_code_0_0 instance = new comparison_reorder_code_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      ITermFactory termFactory = context.getFactory();
      context.push("comparison_reorder_code_0_0");
      Fail197:
      { 
        IStrategoTerm s_59 = null;
        IStrategoTerm t_59 = null;
        IStrategoTerm u_59 = null;
        IStrategoTerm v_59 = null;
        IStrategoTerm w_59 = null;
        IStrategoTerm x_59 = null;
        IStrategoTerm y_59 = null;
        IStrategoTerm z_59 = null;
        IStrategoTerm a_60 = null;
        IStrategoTerm b_60 = null;
        IStrategoTerm c_60 = null;
        IStrategoTerm d_60 = null;
        IStrategoTerm e_60 = null;
        IStrategoTerm f_60 = null;
        IStrategoTerm g_60 = null;
        IStrategoTerm i_60 = null;
        IStrategoTerm j_60 = null;
        IStrategoTerm l_60 = null;
        IStrategoTerm m_60 = null;
        IStrategoTerm o_60 = null;
        IStrategoTerm p_60 = null;
        IStrategoTerm r_60 = null;
        IStrategoTerm s_60 = null;
        IStrategoTerm t_60 = null;
        IStrategoTerm u_60 = null;
        IStrategoTerm v_60 = null;
        IStrategoTerm w_60 = null;
        IStrategoTerm x_60 = null;
        IStrategoTerm y_60 = null;
        IStrategoTerm z_60 = null;
        IStrategoTerm a_61 = null;
        IStrategoTerm b_61 = null;
        IStrategoTerm c_61 = null;
        IStrategoTerm d_61 = null;
        IStrategoTerm e_61 = null;
        e_61 = term;
        d_61 = term;
        term = e_61;
        IStrategoTerm term356 = term;
        Success146:
        { 
          Fail198:
          { 
            IStrategoTerm f_61 = null;
            f_61 = term;
            term = d_61;
            if(term.getTermType() != IStrategoTerm.TUPLE || term.getSubtermCount() != 2)
              break Fail198;
            s_59 = term.getSubterm(0);
            if(term.getSubterm(1) != s_59 && !s_59.match(term.getSubterm(1)))
              break Fail198;
            term = f_61;
            { 
              if(true)
                break Fail197;
              if(true)
                break Success146;
            }
          }
          term = term356;
          IStrategoTerm term357 = term;
          Success147:
          { 
            Fail199:
            { 
              IStrategoTerm g_61 = null;
              g_61 = term;
              term = d_61;
              if(term.getTermType() != IStrategoTerm.TUPLE || term.getSubtermCount() != 2)
                break Fail199;
              IStrategoTerm arg573 = term.getSubterm(0);
              if(arg573.getTermType() != IStrategoTerm.APPL || Simplify._consMul_2 != ((IStrategoAppl)arg573).getConstructor())
                break Fail199;
              IStrategoTerm arg574 = arg573.getSubterm(0);
              if(arg574.getTermType() != IStrategoTerm.APPL || Simplify._consVar_1 != ((IStrategoAppl)arg574).getConstructor())
                break Fail199;
              t_59 = arg574.getSubterm(0);
              IStrategoTerm arg575 = arg573.getSubterm(1);
              if(arg575.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg575).getConstructor())
                break Fail199;
              IStrategoTerm arg577 = term.getSubterm(1);
              if(arg577.getTermType() != IStrategoTerm.APPL || Simplify._consMul_2 != ((IStrategoAppl)arg577).getConstructor())
                break Fail199;
              IStrategoTerm arg578 = arg577.getSubterm(0);
              if(arg578.getTermType() != IStrategoTerm.APPL || Simplify._consVar_1 != ((IStrategoAppl)arg578).getConstructor())
                break Fail199;
              u_59 = arg578.getSubterm(0);
              IStrategoTerm arg579 = arg577.getSubterm(1);
              if(arg579.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg579).getConstructor())
                break Fail199;
              term = g_61;
              { 
                Success148:
                { 
                  Fail200:
                  { 
                    term = termFactory.makeTuple(t_59, u_59);
                    term = variable_name_reorder_0_0.instance.invoke(context, term);
                    if(term == null)
                      break Fail200;
                    { 
                      term = Simplify.constTrue0;
                      if(true)
                        break Success148;
                    }
                  }
                  term = Simplify.constFalse0;
                }
                if(true)
                  break Success147;
              }
            }
            term = term357;
            IStrategoTerm term359 = term;
            Success149:
            { 
              Fail201:
              { 
                IStrategoTerm h_61 = null;
                h_61 = term;
                term = d_61;
                if(term.getTermType() != IStrategoTerm.TUPLE || term.getSubtermCount() != 2)
                  break Fail201;
                IStrategoTerm arg581 = term.getSubterm(0);
                if(arg581.getTermType() != IStrategoTerm.APPL || Simplify._consVar_1 != ((IStrategoAppl)arg581).getConstructor())
                  break Fail201;
                v_59 = arg581.getSubterm(0);
                IStrategoTerm arg582 = term.getSubterm(1);
                if(arg582.getTermType() != IStrategoTerm.APPL || Simplify._consVar_1 != ((IStrategoAppl)arg582).getConstructor())
                  break Fail201;
                w_59 = arg582.getSubterm(0);
                term = h_61;
                { 
                  Success150:
                  { 
                    Fail202:
                    { 
                      term = termFactory.makeTuple(v_59, w_59);
                      term = variable_name_reorder_0_0.instance.invoke(context, term);
                      if(term == null)
                        break Fail202;
                      { 
                        term = Simplify.constTrue0;
                        if(true)
                          break Success150;
                      }
                    }
                    term = Simplify.constFalse0;
                  }
                  if(true)
                    break Success149;
                }
              }
              term = term359;
              IStrategoTerm term361 = term;
              Success151:
              { 
                Fail203:
                { 
                  IStrategoTerm i_61 = null;
                  i_61 = term;
                  term = d_61;
                  if(term.getTermType() != IStrategoTerm.TUPLE || term.getSubtermCount() != 2)
                    break Fail203;
                  IStrategoTerm arg583 = term.getSubterm(0);
                  if(arg583.getTermType() != IStrategoTerm.APPL || Simplify._consAdd_2 != ((IStrategoAppl)arg583).getConstructor())
                    break Fail203;
                  x_59 = arg583.getSubterm(0);
                  z_59 = arg583.getSubterm(1);
                  IStrategoTerm arg584 = term.getSubterm(1);
                  if(arg584.getTermType() != IStrategoTerm.APPL || Simplify._consAdd_2 != ((IStrategoAppl)arg584).getConstructor())
                    break Fail203;
                  y_59 = arg584.getSubterm(0);
                  a_60 = arg584.getSubterm(1);
                  term = i_61;
                  { 
                    Success152:
                    { 
                      Fail204:
                      { 
                        term = termFactory.makeTuple(x_59, y_59);
                        term = this.invoke(context, term);
                        if(term == null)
                          break Fail204;
                        if(true)
                          break Success152;
                      }
                      term = termFactory.makeTuple(z_59, a_60);
                      term = this.invoke(context, term);
                      if(term == null)
                        break Fail197;
                    }
                    if(true)
                      break Success151;
                  }
                }
                term = term361;
                IStrategoTerm term363 = term;
                Success153:
                { 
                  Fail205:
                  { 
                    IStrategoTerm j_61 = null;
                    j_61 = term;
                    term = d_61;
                    if(term.getTermType() != IStrategoTerm.TUPLE || term.getSubtermCount() != 2)
                      break Fail205;
                    IStrategoTerm arg585 = term.getSubterm(0);
                    if(arg585.getTermType() != IStrategoTerm.APPL || Simplify._consMul_2 != ((IStrategoAppl)arg585).getConstructor())
                      break Fail205;
                    b_60 = arg585.getSubterm(0);
                    d_60 = arg585.getSubterm(1);
                    IStrategoTerm arg586 = term.getSubterm(1);
                    if(arg586.getTermType() != IStrategoTerm.APPL || Simplify._consMul_2 != ((IStrategoAppl)arg586).getConstructor())
                      break Fail205;
                    c_60 = arg586.getSubterm(0);
                    e_60 = arg586.getSubterm(1);
                    term = j_61;
                    { 
                      Success154:
                      { 
                        Fail206:
                        { 
                          term = termFactory.makeTuple(b_60, c_60);
                          term = this.invoke(context, term);
                          if(term == null)
                            break Fail206;
                          if(true)
                            break Success154;
                        }
                        term = termFactory.makeTuple(d_60, e_60);
                        term = this.invoke(context, term);
                        if(term == null)
                          break Fail197;
                      }
                      if(true)
                        break Success153;
                    }
                  }
                  term = term363;
                  IStrategoTerm term365 = term;
                  Success155:
                  { 
                    Fail207:
                    { 
                      IStrategoTerm k_61 = null;
                      k_61 = term;
                      term = d_61;
                      if(term.getTermType() != IStrategoTerm.TUPLE || term.getSubtermCount() != 2)
                        break Fail207;
                      IStrategoTerm arg587 = term.getSubterm(0);
                      if(arg587.getTermType() != IStrategoTerm.APPL || Simplify._consNeg_1 != ((IStrategoAppl)arg587).getConstructor())
                        break Fail207;
                      f_60 = arg587.getSubterm(0);
                      IStrategoTerm arg588 = term.getSubterm(1);
                      if(arg588.getTermType() != IStrategoTerm.APPL || Simplify._consNeg_1 != ((IStrategoAppl)arg588).getConstructor())
                        break Fail207;
                      g_60 = arg588.getSubterm(0);
                      term = k_61;
                      { 
                        term = termFactory.makeTuple(f_60, g_60);
                        term = this.invoke(context, term);
                        if(term == null)
                          break Fail197;
                        if(true)
                          break Success155;
                      }
                    }
                    term = term365;
                    IStrategoTerm term366 = term;
                    Success156:
                    { 
                      Fail208:
                      { 
                        IStrategoTerm l_61 = null;
                        l_61 = term;
                        term = d_61;
                        if(term.getTermType() != IStrategoTerm.TUPLE || term.getSubtermCount() != 2)
                          break Fail208;
                        IStrategoTerm arg589 = term.getSubterm(0);
                        if(arg589.getTermType() != IStrategoTerm.APPL || Simplify._consAdd_2 != ((IStrategoAppl)arg589).getConstructor())
                          break Fail208;
                        i_60 = arg589.getSubterm(0);
                        j_60 = term.getSubterm(1);
                        term = l_61;
                        { 
                          Success157:
                          { 
                            Fail209:
                            { 
                              term = termFactory.makeTuple(i_60, j_60);
                              term = this.invoke(context, term);
                              if(term == null)
                                break Fail209;
                              if(true)
                                break Success157;
                            }
                            term = Simplify.constTrue0;
                          }
                          if(true)
                            break Success156;
                        }
                      }
                      term = term366;
                      IStrategoTerm term368 = term;
                      Success158:
                      { 
                        Fail210:
                        { 
                          IStrategoTerm m_61 = null;
                          m_61 = term;
                          term = d_61;
                          if(term.getTermType() != IStrategoTerm.TUPLE || term.getSubtermCount() != 2)
                            break Fail210;
                          l_60 = term.getSubterm(0);
                          IStrategoTerm arg590 = term.getSubterm(1);
                          if(arg590.getTermType() != IStrategoTerm.APPL || Simplify._consAdd_2 != ((IStrategoAppl)arg590).getConstructor())
                            break Fail210;
                          m_60 = arg590.getSubterm(0);
                          term = m_61;
                          { 
                            Success159:
                            { 
                              Fail211:
                              { 
                                term = termFactory.makeTuple(l_60, m_60);
                                term = this.invoke(context, term);
                                if(term == null)
                                  break Fail211;
                                if(true)
                                  break Success159;
                              }
                              term = Simplify.constFalse0;
                            }
                            if(true)
                              break Success158;
                          }
                        }
                        term = term368;
                        IStrategoTerm term370 = term;
                        Success160:
                        { 
                          Fail212:
                          { 
                            IStrategoTerm n_61 = null;
                            n_61 = term;
                            term = d_61;
                            if(term.getTermType() != IStrategoTerm.TUPLE || term.getSubtermCount() != 2)
                              break Fail212;
                            IStrategoTerm arg591 = term.getSubterm(0);
                            if(arg591.getTermType() != IStrategoTerm.APPL || Simplify._consMul_2 != ((IStrategoAppl)arg591).getConstructor())
                              break Fail212;
                            o_60 = arg591.getSubterm(0);
                            p_60 = term.getSubterm(1);
                            term = n_61;
                            { 
                              Success161:
                              { 
                                Fail213:
                                { 
                                  term = termFactory.makeTuple(o_60, p_60);
                                  term = this.invoke(context, term);
                                  if(term == null)
                                    break Fail213;
                                  if(true)
                                    break Success161;
                                }
                                term = Simplify.constTrue0;
                              }
                              if(true)
                                break Success160;
                            }
                          }
                          term = term370;
                          IStrategoTerm term372 = term;
                          Success162:
                          { 
                            Fail214:
                            { 
                              IStrategoTerm o_61 = null;
                              o_61 = term;
                              term = d_61;
                              if(term.getTermType() != IStrategoTerm.TUPLE || term.getSubtermCount() != 2)
                                break Fail214;
                              r_60 = term.getSubterm(0);
                              IStrategoTerm arg592 = term.getSubterm(1);
                              if(arg592.getTermType() != IStrategoTerm.APPL || Simplify._consMul_2 != ((IStrategoAppl)arg592).getConstructor())
                                break Fail214;
                              s_60 = arg592.getSubterm(0);
                              term = o_61;
                              { 
                                Success163:
                                { 
                                  Fail215:
                                  { 
                                    term = termFactory.makeTuple(r_60, s_60);
                                    term = this.invoke(context, term);
                                    if(term == null)
                                      break Fail215;
                                    if(true)
                                      break Success163;
                                  }
                                  term = Simplify.constFalse0;
                                }
                                if(true)
                                  break Success162;
                              }
                            }
                            term = term372;
                            IStrategoTerm term374 = term;
                            Success164:
                            { 
                              Fail216:
                              { 
                                IStrategoTerm p_61 = null;
                                p_61 = term;
                                term = d_61;
                                if(term.getTermType() != IStrategoTerm.TUPLE || term.getSubtermCount() != 2)
                                  break Fail216;
                                IStrategoTerm arg593 = term.getSubterm(0);
                                if(arg593.getTermType() != IStrategoTerm.APPL || Simplify._consNeg_1 != ((IStrategoAppl)arg593).getConstructor())
                                  break Fail216;
                                t_60 = arg593.getSubterm(0);
                                u_60 = term.getSubterm(1);
                                term = p_61;
                                { 
                                  Success165:
                                  { 
                                    Fail217:
                                    { 
                                      term = termFactory.makeTuple(t_60, u_60);
                                      term = this.invoke(context, term);
                                      if(term == null)
                                        break Fail217;
                                      if(true)
                                        break Success165;
                                    }
                                    term = Simplify.constTrue0;
                                  }
                                  if(true)
                                    break Success164;
                                }
                              }
                              term = term374;
                              IStrategoTerm term376 = term;
                              Success166:
                              { 
                                Fail218:
                                { 
                                  IStrategoTerm q_61 = null;
                                  q_61 = term;
                                  term = d_61;
                                  if(term.getTermType() != IStrategoTerm.TUPLE || term.getSubtermCount() != 2)
                                    break Fail218;
                                  v_60 = term.getSubterm(0);
                                  IStrategoTerm arg594 = term.getSubterm(1);
                                  if(arg594.getTermType() != IStrategoTerm.APPL || Simplify._consNeg_1 != ((IStrategoAppl)arg594).getConstructor())
                                    break Fail218;
                                  w_60 = arg594.getSubterm(0);
                                  term = q_61;
                                  { 
                                    Success167:
                                    { 
                                      Fail219:
                                      { 
                                        term = termFactory.makeTuple(v_60, w_60);
                                        term = this.invoke(context, term);
                                        if(term == null)
                                          break Fail219;
                                        if(true)
                                          break Success167;
                                      }
                                      term = Simplify.constFalse0;
                                    }
                                    if(true)
                                      break Success166;
                                  }
                                }
                                term = term376;
                                if(term.getTermType() != IStrategoTerm.TUPLE || term.getSubtermCount() != 2)
                                  break Fail197;
                                x_60 = term.getSubterm(0);
                                c_61 = term.getSubterm(1);
                                Success168:
                                { 
                                  Fail220:
                                  { 
                                    IStrategoTerm r_61 = null;
                                    r_61 = term;
                                    term = is_comparison_0_0.instance.invoke(context, x_60);
                                    if(term == null)
                                      break Fail220;
                                    if(term.getTermType() != IStrategoTerm.TUPLE || term.getSubtermCount() != 2)
                                      break Fail220;
                                    a_61 = term.getSubterm(0);
                                    y_60 = term.getSubterm(1);
                                    term = r_61;
                                    { 
                                      Success169:
                                      { 
                                        Fail221:
                                        { 
                                          IStrategoTerm s_61 = null;
                                          s_61 = term;
                                          term = is_comparison_0_0.instance.invoke(context, c_61);
                                          if(term == null)
                                            break Fail221;
                                          if(term.getTermType() != IStrategoTerm.TUPLE || term.getSubtermCount() != 2)
                                            break Fail221;
                                          b_61 = term.getSubterm(0);
                                          z_60 = term.getSubterm(1);
                                          term = s_61;
                                          { 
                                            IStrategoTerm term380 = term;
                                            Success170:
                                            { 
                                              Fail222:
                                              { 
                                                term = termFactory.makeTuple(y_60, z_60);
                                                term = this.invoke(context, term);
                                                if(term == null)
                                                  break Fail222;
                                                if(true)
                                                  break Success170;
                                              }
                                              term = term380;
                                              Success171:
                                              { 
                                                Fail223:
                                                { 
                                                  term = termFactory.makeTuple(a_61, b_61);
                                                  term = leq$S_0_0.instance.invoke(context, term);
                                                  if(term == null)
                                                    break Fail223;
                                                  { 
                                                    term = Simplify.constFalse0;
                                                    if(true)
                                                      break Success171;
                                                  }
                                                }
                                                term = Simplify.constTrue0;
                                              }
                                            }
                                            if(true)
                                              break Success169;
                                          }
                                        }
                                        term = Simplify.constTrue0;
                                      }
                                      if(true)
                                        break Success168;
                                    }
                                  }
                                  term = is_comparison_0_0.instance.invoke(context, c_61);
                                  if(term == null)
                                    break Fail197;
                                  term = Simplify.constFalse0;
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class is_comparison_0_0 extends Strategy 
  { 
    public static is_comparison_0_0 instance = new is_comparison_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      ITermFactory termFactory = context.getFactory();
      Fail224:
      { 
        IStrategoTerm term382 = term;
        IStrategoConstructor cons34 = term.getTermType() == IStrategoTerm.APPL ? ((IStrategoAppl)term).getConstructor() : null;
        Success172:
        { 
          if(cons34 == Simplify._consLt_2)
          { 
            Fail225:
            { 
              IStrategoTerm f_62 = null;
              f_62 = term.getSubterm(0);
              IStrategoTerm arg595 = term.getSubterm(1);
              if(arg595.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg595).getConstructor())
                break Fail225;
              term = termFactory.makeTuple(Simplify.const54, f_62);
              if(true)
                break Success172;
            }
            term = term382;
          }
          Success173:
          { 
            if(cons34 == Simplify._consLeq_2)
            { 
              Fail226:
              { 
                IStrategoTerm d_62 = null;
                d_62 = term.getSubterm(0);
                IStrategoTerm arg596 = term.getSubterm(1);
                if(arg596.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg596).getConstructor())
                  break Fail226;
                term = termFactory.makeTuple(Simplify.const108, d_62);
                if(true)
                  break Success173;
              }
              term = term382;
            }
            Success174:
            { 
              if(cons34 == Simplify._consEqu_2)
              { 
                Fail227:
                { 
                  IStrategoTerm b_62 = null;
                  b_62 = term.getSubterm(0);
                  IStrategoTerm arg597 = term.getSubterm(1);
                  if(arg597.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg597).getConstructor())
                    break Fail227;
                  term = termFactory.makeTuple(Simplify.const109, b_62);
                  if(true)
                    break Success174;
                }
                term = term382;
              }
              Success175:
              { 
                if(cons34 == Simplify._consGeq_2)
                { 
                  Fail228:
                  { 
                    IStrategoTerm z_61 = null;
                    z_61 = term.getSubterm(0);
                    IStrategoTerm arg598 = term.getSubterm(1);
                    if(arg598.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg598).getConstructor())
                      break Fail228;
                    term = termFactory.makeTuple(Simplify.const110, z_61);
                    if(true)
                      break Success175;
                  }
                  term = term382;
                }
                Success176:
                { 
                  if(cons34 == Simplify._consGt_2)
                  { 
                    Fail229:
                    { 
                      IStrategoTerm x_61 = null;
                      x_61 = term.getSubterm(0);
                      IStrategoTerm arg599 = term.getSubterm(1);
                      if(arg599.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg599).getConstructor())
                        break Fail229;
                      term = termFactory.makeTuple(Simplify.const111, x_61);
                      if(true)
                        break Success176;
                    }
                    term = term382;
                  }
                  if(cons34 == Simplify._consNeq_2)
                  { 
                    IStrategoTerm v_61 = null;
                    v_61 = term.getSubterm(0);
                    IStrategoTerm arg600 = term.getSubterm(1);
                    if(arg600.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg600).getConstructor())
                      break Fail224;
                    term = termFactory.makeTuple(Simplify.const53, v_61);
                  }
                  else
                  { 
                    break Fail224;
                  }
                }
              }
            }
          }
        }
        if(true)
          return term;
      }
      context.push("is_comparison_0_0");
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class $Sort$Compare_0_0 extends Strategy 
  { 
    public static $Sort$Compare_0_0 instance = new $Sort$Compare_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      ITermFactory termFactory = context.getFactory();
      context.push("SortCompare_0_0");
      Fail230:
      { 
        IStrategoTerm term387 = term;
        IStrategoConstructor cons35 = term.getTermType() == IStrategoTerm.APPL ? ((IStrategoAppl)term).getConstructor() : null;
        Success177:
        { 
          if(cons35 == Simplify._consAnd_2)
          { 
            Fail231:
            { 
              IStrategoTerm s_62 = null;
              IStrategoTerm v_62 = null;
              s_62 = term.getSubterm(0);
              v_62 = term.getSubterm(1);
              term = termFactory.makeTuple(s_62, v_62);
              term = comparison_reorder_0_0.instance.invoke(context, term);
              if(term == null)
                break Fail231;
              term = termFactory.makeAppl(Simplify._consAnd_2, new IStrategoTerm[]{v_62, s_62});
              if(true)
                break Success177;
            }
            term = term387;
          }
          Success178:
          { 
            if(cons35 == Simplify._consAnd_2)
            { 
              Fail232:
              { 
                IStrategoTerm o_62 = null;
                IStrategoTerm p_62 = null;
                IStrategoTerm q_62 = null;
                IStrategoTerm arg601 = term.getSubterm(0);
                if(arg601.getTermType() != IStrategoTerm.APPL || Simplify._consAnd_2 != ((IStrategoAppl)arg601).getConstructor())
                  break Fail232;
                o_62 = arg601.getSubterm(0);
                p_62 = arg601.getSubterm(1);
                q_62 = term.getSubterm(1);
                term = termFactory.makeTuple(p_62, q_62);
                term = comparison_reorder_0_0.instance.invoke(context, term);
                if(term == null)
                  break Fail232;
                term = termFactory.makeAppl(Simplify._consAnd_2, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consAnd_2, new IStrategoTerm[]{o_62, q_62}), p_62});
                if(true)
                  break Success178;
              }
              term = term387;
            }
            Success179:
            { 
              if(cons35 == Simplify._consOr_2)
              { 
                Fail233:
                { 
                  IStrategoTerm l_62 = null;
                  IStrategoTerm m_62 = null;
                  l_62 = term.getSubterm(0);
                  m_62 = term.getSubterm(1);
                  term = termFactory.makeTuple(l_62, m_62);
                  term = comparison_reorder_0_0.instance.invoke(context, term);
                  if(term == null)
                    break Fail233;
                  term = termFactory.makeAppl(Simplify._consOr_2, new IStrategoTerm[]{m_62, l_62});
                  if(true)
                    break Success179;
                }
                term = term387;
              }
              if(cons35 == Simplify._consOr_2)
              { 
                IStrategoTerm g_62 = null;
                IStrategoTerm h_62 = null;
                IStrategoTerm i_62 = null;
                IStrategoTerm arg602 = term.getSubterm(0);
                if(arg602.getTermType() != IStrategoTerm.APPL || Simplify._consOr_2 != ((IStrategoAppl)arg602).getConstructor())
                  break Fail230;
                g_62 = arg602.getSubterm(0);
                h_62 = arg602.getSubterm(1);
                i_62 = term.getSubterm(1);
                term = termFactory.makeTuple(h_62, i_62);
                term = comparison_reorder_0_0.instance.invoke(context, term);
                if(term == null)
                  break Fail230;
                term = termFactory.makeAppl(Simplify._consOr_2, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consOr_2, new IStrategoTerm[]{g_62, i_62}), h_62});
              }
              else
              { 
                break Fail230;
              }
            }
          }
        }
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class $Merge$Compare_0_0_fragment_0 extends Strategy 
  { 
    public static $Merge$Compare_0_0_fragment_0 instance = new $Merge$Compare_0_0_fragment_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      ITermFactory termFactory = context.getFactory();
      context.push("MergeCompare_0_0_fragment_0");
      Fail234:
      { 
        IStrategoTerm term390 = term;
        IStrategoConstructor cons36 = term.getTermType() == IStrategoTerm.APPL ? ((IStrategoAppl)term).getConstructor() : null;
        Success180:
        { 
          if(cons36 == Simplify._consAnd_2)
          { 
            Fail235:
            { 
              IStrategoTerm s_69 = null;
              IStrategoTerm t_69 = null;
              IStrategoTerm u_69 = null;
              IStrategoTerm v_69 = null;
              IStrategoTerm arg603 = term.getSubterm(0);
              if(arg603.getTermType() != IStrategoTerm.APPL || Simplify._consAnd_2 != ((IStrategoAppl)arg603).getConstructor())
                break Fail235;
              s_69 = arg603.getSubterm(0);
              IStrategoTerm arg604 = arg603.getSubterm(1);
              if(arg604.getTermType() != IStrategoTerm.APPL || Simplify._consLt_2 != ((IStrategoAppl)arg604).getConstructor())
                break Fail235;
              t_69 = arg604.getSubterm(0);
              IStrategoTerm arg605 = arg604.getSubterm(1);
              if(arg605.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg605).getConstructor())
                break Fail235;
              u_69 = arg605.getSubterm(0);
              IStrategoTerm arg606 = term.getSubterm(1);
              if(arg606.getTermType() != IStrategoTerm.APPL || Simplify._consLeq_2 != ((IStrategoAppl)arg606).getConstructor())
                break Fail235;
              if(arg606.getSubterm(0) != t_69 && !t_69.match(arg606.getSubterm(0)))
                break Fail235;
              IStrategoTerm arg607 = arg606.getSubterm(1);
              if(arg607.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg607).getConstructor())
                break Fail235;
              v_69 = arg607.getSubterm(0);
              term = termFactory.makeTuple(u_69, v_69);
              term = leq$S_0_0.instance.invoke(context, term);
              if(term == null)
                break Fail235;
              term = termFactory.makeAppl(Simplify._consAnd_2, new IStrategoTerm[]{s_69, termFactory.makeAppl(Simplify._consLt_2, new IStrategoTerm[]{t_69, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{u_69})})});
              if(true)
                break Success180;
            }
            term = term390;
          }
          Success181:
          { 
            if(cons36 == Simplify._consAnd_2)
            { 
              Fail236:
              { 
                IStrategoTerm k_69 = null;
                IStrategoTerm n_69 = null;
                IStrategoTerm o_69 = null;
                IStrategoTerm p_69 = null;
                IStrategoTerm arg608 = term.getSubterm(0);
                if(arg608.getTermType() != IStrategoTerm.APPL || Simplify._consAnd_2 != ((IStrategoAppl)arg608).getConstructor())
                  break Fail236;
                k_69 = arg608.getSubterm(0);
                IStrategoTerm arg609 = arg608.getSubterm(1);
                if(arg609.getTermType() != IStrategoTerm.APPL || Simplify._consLeq_2 != ((IStrategoAppl)arg609).getConstructor())
                  break Fail236;
                n_69 = arg609.getSubterm(0);
                IStrategoTerm arg610 = arg609.getSubterm(1);
                if(arg610.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg610).getConstructor())
                  break Fail236;
                o_69 = arg610.getSubterm(0);
                IStrategoTerm arg611 = term.getSubterm(1);
                if(arg611.getTermType() != IStrategoTerm.APPL || Simplify._consLeq_2 != ((IStrategoAppl)arg611).getConstructor())
                  break Fail236;
                if(arg611.getSubterm(0) != n_69 && !n_69.match(arg611.getSubterm(0)))
                  break Fail236;
                IStrategoTerm arg612 = arg611.getSubterm(1);
                if(arg612.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg612).getConstructor())
                  break Fail236;
                p_69 = arg612.getSubterm(0);
                term = termFactory.makeTuple(o_69, p_69);
                term = minstring_0_0.instance.invoke(context, term);
                if(term == null)
                  break Fail236;
                term = termFactory.makeAppl(Simplify._consAnd_2, new IStrategoTerm[]{k_69, termFactory.makeAppl(Simplify._consLeq_2, new IStrategoTerm[]{n_69, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{term})})});
                if(true)
                  break Success181;
              }
              term = term390;
            }
            Success182:
            { 
              if(cons36 == Simplify._consAnd_2)
              { 
                Fail237:
                { 
                  IStrategoTerm e_68 = null;
                  IStrategoTerm c_69 = null;
                  IStrategoTerm d_69 = null;
                  IStrategoTerm arg613 = term.getSubterm(0);
                  if(arg613.getTermType() != IStrategoTerm.APPL || Simplify._consAnd_2 != ((IStrategoAppl)arg613).getConstructor())
                    break Fail237;
                  IStrategoTerm arg614 = arg613.getSubterm(1);
                  if(arg614.getTermType() != IStrategoTerm.APPL || Simplify._consEqu_2 != ((IStrategoAppl)arg614).getConstructor())
                    break Fail237;
                  e_68 = arg614.getSubterm(0);
                  IStrategoTerm arg615 = arg614.getSubterm(1);
                  if(arg615.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg615).getConstructor())
                    break Fail237;
                  c_69 = arg615.getSubterm(0);
                  IStrategoTerm arg616 = term.getSubterm(1);
                  if(arg616.getTermType() != IStrategoTerm.APPL || Simplify._consEqu_2 != ((IStrategoAppl)arg616).getConstructor())
                    break Fail237;
                  if(arg616.getSubterm(0) != e_68 && !e_68.match(arg616.getSubterm(0)))
                    break Fail237;
                  IStrategoTerm arg617 = arg616.getSubterm(1);
                  if(arg617.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg617).getConstructor())
                    break Fail237;
                  d_69 = arg617.getSubterm(0);
                  term = termFactory.makeTuple(c_69, d_69);
                  IStrategoTerm term393 = term;
                  Success183:
                  { 
                    Fail238:
                    { 
                      term = eq_0_0.instance.invoke(context, term);
                      if(term == null)
                        break Fail238;
                      { 
                        if(true)
                          break Fail237;
                        if(true)
                          break Success183;
                      }
                    }
                    term = term393;
                  }
                  term = Simplify.constFalse0;
                  if(true)
                    break Success182;
                }
                term = term390;
              }
              Success184:
              { 
                if(cons36 == Simplify._consAnd_2)
                { 
                  Fail239:
                  { 
                    IStrategoTerm j_67 = null;
                    IStrategoTerm r_67 = null;
                    IStrategoTerm s_67 = null;
                    IStrategoTerm arg618 = term.getSubterm(0);
                    if(arg618.getTermType() != IStrategoTerm.APPL || Simplify._consAnd_2 != ((IStrategoAppl)arg618).getConstructor())
                      break Fail239;
                    j_67 = arg618.getSubterm(0);
                    IStrategoTerm arg619 = arg618.getSubterm(1);
                    if(arg619.getTermType() != IStrategoTerm.APPL || Simplify._consEqu_2 != ((IStrategoAppl)arg619).getConstructor())
                      break Fail239;
                    r_67 = arg619.getSubterm(0);
                    IStrategoTerm arg620 = arg619.getSubterm(1);
                    if(arg620.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg620).getConstructor())
                      break Fail239;
                    s_67 = arg620.getSubterm(0);
                    IStrategoTerm arg621 = term.getSubterm(1);
                    if(arg621.getTermType() != IStrategoTerm.APPL || Simplify._consEqu_2 != ((IStrategoAppl)arg621).getConstructor())
                      break Fail239;
                    if(arg621.getSubterm(0) != r_67 && !r_67.match(arg621.getSubterm(0)))
                      break Fail239;
                    IStrategoTerm arg622 = arg621.getSubterm(1);
                    if(arg622.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg622).getConstructor())
                      break Fail239;
                    if(arg622.getSubterm(0) != s_67 && !s_67.match(arg622.getSubterm(0)))
                      break Fail239;
                    term = termFactory.makeAppl(Simplify._consAnd_2, new IStrategoTerm[]{j_67, termFactory.makeAppl(Simplify._consEqu_2, new IStrategoTerm[]{r_67, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{s_67})})});
                    if(true)
                      break Success184;
                  }
                  term = term390;
                }
                Success185:
                { 
                  if(cons36 == Simplify._consAnd_2)
                  { 
                    Fail240:
                    { 
                      IStrategoTerm x_66 = null;
                      IStrategoTerm a_67 = null;
                      IStrategoTerm b_67 = null;
                      IStrategoTerm g_67 = null;
                      IStrategoTerm arg623 = term.getSubterm(0);
                      if(arg623.getTermType() != IStrategoTerm.APPL || Simplify._consAnd_2 != ((IStrategoAppl)arg623).getConstructor())
                        break Fail240;
                      x_66 = arg623.getSubterm(0);
                      IStrategoTerm arg624 = arg623.getSubterm(1);
                      if(arg624.getTermType() != IStrategoTerm.APPL || Simplify._consGeq_2 != ((IStrategoAppl)arg624).getConstructor())
                        break Fail240;
                      a_67 = arg624.getSubterm(0);
                      IStrategoTerm arg625 = arg624.getSubterm(1);
                      if(arg625.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg625).getConstructor())
                        break Fail240;
                      b_67 = arg625.getSubterm(0);
                      IStrategoTerm arg626 = term.getSubterm(1);
                      if(arg626.getTermType() != IStrategoTerm.APPL || Simplify._consGeq_2 != ((IStrategoAppl)arg626).getConstructor())
                        break Fail240;
                      if(arg626.getSubterm(0) != a_67 && !a_67.match(arg626.getSubterm(0)))
                        break Fail240;
                      IStrategoTerm arg627 = arg626.getSubterm(1);
                      if(arg627.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg627).getConstructor())
                        break Fail240;
                      g_67 = arg627.getSubterm(0);
                      term = termFactory.makeTuple(b_67, g_67);
                      term = maxstring_0_0.instance.invoke(context, term);
                      if(term == null)
                        break Fail240;
                      term = termFactory.makeAppl(Simplify._consAnd_2, new IStrategoTerm[]{x_66, termFactory.makeAppl(Simplify._consGeq_2, new IStrategoTerm[]{a_67, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{term})})});
                      if(true)
                        break Success185;
                    }
                    term = term390;
                  }
                  Success186:
                  { 
                    if(cons36 == Simplify._consAnd_2)
                    { 
                      Fail241:
                      { 
                        IStrategoTerm s_66 = null;
                        IStrategoTerm t_66 = null;
                        IStrategoTerm u_66 = null;
                        IStrategoTerm v_66 = null;
                        IStrategoTerm arg628 = term.getSubterm(0);
                        if(arg628.getTermType() != IStrategoTerm.APPL || Simplify._consAnd_2 != ((IStrategoAppl)arg628).getConstructor())
                          break Fail241;
                        s_66 = arg628.getSubterm(0);
                        IStrategoTerm arg629 = arg628.getSubterm(1);
                        if(arg629.getTermType() != IStrategoTerm.APPL || Simplify._consGeq_2 != ((IStrategoAppl)arg629).getConstructor())
                          break Fail241;
                        t_66 = arg629.getSubterm(0);
                        IStrategoTerm arg630 = arg629.getSubterm(1);
                        if(arg630.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg630).getConstructor())
                          break Fail241;
                        u_66 = arg630.getSubterm(0);
                        IStrategoTerm arg631 = term.getSubterm(1);
                        if(arg631.getTermType() != IStrategoTerm.APPL || Simplify._consGt_2 != ((IStrategoAppl)arg631).getConstructor())
                          break Fail241;
                        if(arg631.getSubterm(0) != t_66 && !t_66.match(arg631.getSubterm(0)))
                          break Fail241;
                        IStrategoTerm arg632 = arg631.getSubterm(1);
                        if(arg632.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg632).getConstructor())
                          break Fail241;
                        v_66 = arg632.getSubterm(0);
                        term = termFactory.makeTuple(u_66, v_66);
                        term = gt$S_0_0.instance.invoke(context, term);
                        if(term == null)
                          break Fail241;
                        term = termFactory.makeAppl(Simplify._consAnd_2, new IStrategoTerm[]{s_66, termFactory.makeAppl(Simplify._consGeq_2, new IStrategoTerm[]{t_66, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{u_66})})});
                        if(true)
                          break Success186;
                      }
                      term = term390;
                    }
                    Success187:
                    { 
                      if(cons36 == Simplify._consAnd_2)
                      { 
                        Fail242:
                        { 
                          IStrategoTerm n_66 = null;
                          IStrategoTerm o_66 = null;
                          IStrategoTerm p_66 = null;
                          IStrategoTerm q_66 = null;
                          IStrategoTerm arg633 = term.getSubterm(0);
                          if(arg633.getTermType() != IStrategoTerm.APPL || Simplify._consAnd_2 != ((IStrategoAppl)arg633).getConstructor())
                            break Fail242;
                          n_66 = arg633.getSubterm(0);
                          IStrategoTerm arg634 = arg633.getSubterm(1);
                          if(arg634.getTermType() != IStrategoTerm.APPL || Simplify._consGeq_2 != ((IStrategoAppl)arg634).getConstructor())
                            break Fail242;
                          o_66 = arg634.getSubterm(0);
                          IStrategoTerm arg635 = arg634.getSubterm(1);
                          if(arg635.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg635).getConstructor())
                            break Fail242;
                          p_66 = arg635.getSubterm(0);
                          IStrategoTerm arg636 = term.getSubterm(1);
                          if(arg636.getTermType() != IStrategoTerm.APPL || Simplify._consGt_2 != ((IStrategoAppl)arg636).getConstructor())
                            break Fail242;
                          if(arg636.getSubterm(0) != o_66 && !o_66.match(arg636.getSubterm(0)))
                            break Fail242;
                          IStrategoTerm arg637 = arg636.getSubterm(1);
                          if(arg637.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg637).getConstructor())
                            break Fail242;
                          q_66 = arg637.getSubterm(0);
                          term = termFactory.makeTuple(p_66, q_66);
                          term = leq$S_0_0.instance.invoke(context, term);
                          if(term == null)
                            break Fail242;
                          term = termFactory.makeAppl(Simplify._consAnd_2, new IStrategoTerm[]{n_66, termFactory.makeAppl(Simplify._consGt_2, new IStrategoTerm[]{o_66, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{q_66})})});
                          if(true)
                            break Success187;
                        }
                        term = term390;
                      }
                      Success188:
                      { 
                        if(cons36 == Simplify._consAnd_2)
                        { 
                          Fail243:
                          { 
                            IStrategoTerm h_66 = null;
                            IStrategoTerm i_66 = null;
                            IStrategoTerm j_66 = null;
                            IStrategoTerm k_66 = null;
                            IStrategoTerm arg638 = term.getSubterm(0);
                            if(arg638.getTermType() != IStrategoTerm.APPL || Simplify._consAnd_2 != ((IStrategoAppl)arg638).getConstructor())
                              break Fail243;
                            h_66 = arg638.getSubterm(0);
                            IStrategoTerm arg639 = arg638.getSubterm(1);
                            if(arg639.getTermType() != IStrategoTerm.APPL || Simplify._consGt_2 != ((IStrategoAppl)arg639).getConstructor())
                              break Fail243;
                            i_66 = arg639.getSubterm(0);
                            IStrategoTerm arg640 = arg639.getSubterm(1);
                            if(arg640.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg640).getConstructor())
                              break Fail243;
                            j_66 = arg640.getSubterm(0);
                            IStrategoTerm arg641 = term.getSubterm(1);
                            if(arg641.getTermType() != IStrategoTerm.APPL || Simplify._consGt_2 != ((IStrategoAppl)arg641).getConstructor())
                              break Fail243;
                            if(arg641.getSubterm(0) != i_66 && !i_66.match(arg641.getSubterm(0)))
                              break Fail243;
                            IStrategoTerm arg642 = arg641.getSubterm(1);
                            if(arg642.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg642).getConstructor())
                              break Fail243;
                            k_66 = arg642.getSubterm(0);
                            term = termFactory.makeTuple(j_66, k_66);
                            term = maxstring_0_0.instance.invoke(context, term);
                            if(term == null)
                              break Fail243;
                            term = termFactory.makeAppl(Simplify._consAnd_2, new IStrategoTerm[]{h_66, termFactory.makeAppl(Simplify._consGt_2, new IStrategoTerm[]{i_66, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{term})})});
                            if(true)
                              break Success188;
                          }
                          term = term390;
                        }
                        Success189:
                        { 
                          if(cons36 == Simplify._consOr_2)
                          { 
                            Fail244:
                            { 
                              IStrategoTerm c_66 = null;
                              IStrategoTerm d_66 = null;
                              IStrategoTerm e_66 = null;
                              IStrategoTerm arg643 = term.getSubterm(0);
                              if(arg643.getTermType() != IStrategoTerm.APPL || Simplify._consLt_2 != ((IStrategoAppl)arg643).getConstructor())
                                break Fail244;
                              c_66 = arg643.getSubterm(0);
                              IStrategoTerm arg644 = arg643.getSubterm(1);
                              if(arg644.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg644).getConstructor())
                                break Fail244;
                              d_66 = arg644.getSubterm(0);
                              IStrategoTerm arg645 = term.getSubterm(1);
                              if(arg645.getTermType() != IStrategoTerm.APPL || Simplify._consLt_2 != ((IStrategoAppl)arg645).getConstructor())
                                break Fail244;
                              if(arg645.getSubterm(0) != c_66 && !c_66.match(arg645.getSubterm(0)))
                                break Fail244;
                              IStrategoTerm arg646 = arg645.getSubterm(1);
                              if(arg646.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg646).getConstructor())
                                break Fail244;
                              e_66 = arg646.getSubterm(0);
                              term = termFactory.makeTuple(d_66, e_66);
                              term = maxstring_0_0.instance.invoke(context, term);
                              if(term == null)
                                break Fail244;
                              term = termFactory.makeAppl(Simplify._consLt_2, new IStrategoTerm[]{c_66, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{term})});
                              if(true)
                                break Success189;
                            }
                            term = term390;
                          }
                          Success190:
                          { 
                            if(cons36 == Simplify._consOr_2)
                            { 
                              Fail245:
                              { 
                                IStrategoTerm y_65 = null;
                                IStrategoTerm z_65 = null;
                                IStrategoTerm a_66 = null;
                                IStrategoTerm arg647 = term.getSubterm(0);
                                if(arg647.getTermType() != IStrategoTerm.APPL || Simplify._consLt_2 != ((IStrategoAppl)arg647).getConstructor())
                                  break Fail245;
                                y_65 = arg647.getSubterm(0);
                                IStrategoTerm arg648 = arg647.getSubterm(1);
                                if(arg648.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg648).getConstructor())
                                  break Fail245;
                                z_65 = arg648.getSubterm(0);
                                IStrategoTerm arg649 = term.getSubterm(1);
                                if(arg649.getTermType() != IStrategoTerm.APPL || Simplify._consLeq_2 != ((IStrategoAppl)arg649).getConstructor())
                                  break Fail245;
                                if(arg649.getSubterm(0) != y_65 && !y_65.match(arg649.getSubterm(0)))
                                  break Fail245;
                                IStrategoTerm arg650 = arg649.getSubterm(1);
                                if(arg650.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg650).getConstructor())
                                  break Fail245;
                                a_66 = arg650.getSubterm(0);
                                term = termFactory.makeTuple(z_65, a_66);
                                term = leq$S_0_0.instance.invoke(context, term);
                                if(term == null)
                                  break Fail245;
                                term = termFactory.makeAppl(Simplify._consLeq_2, new IStrategoTerm[]{y_65, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{a_66})});
                                if(true)
                                  break Success190;
                              }
                              term = term390;
                            }
                            Success191:
                            { 
                              if(cons36 == Simplify._consOr_2)
                              { 
                                Fail246:
                                { 
                                  IStrategoTerm u_65 = null;
                                  IStrategoTerm v_65 = null;
                                  IStrategoTerm w_65 = null;
                                  IStrategoTerm arg651 = term.getSubterm(0);
                                  if(arg651.getTermType() != IStrategoTerm.APPL || Simplify._consLt_2 != ((IStrategoAppl)arg651).getConstructor())
                                    break Fail246;
                                  u_65 = arg651.getSubterm(0);
                                  IStrategoTerm arg652 = arg651.getSubterm(1);
                                  if(arg652.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg652).getConstructor())
                                    break Fail246;
                                  v_65 = arg652.getSubterm(0);
                                  IStrategoTerm arg653 = term.getSubterm(1);
                                  if(arg653.getTermType() != IStrategoTerm.APPL || Simplify._consLeq_2 != ((IStrategoAppl)arg653).getConstructor())
                                    break Fail246;
                                  if(arg653.getSubterm(0) != u_65 && !u_65.match(arg653.getSubterm(0)))
                                    break Fail246;
                                  IStrategoTerm arg654 = arg653.getSubterm(1);
                                  if(arg654.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg654).getConstructor())
                                    break Fail246;
                                  w_65 = arg654.getSubterm(0);
                                  term = termFactory.makeTuple(v_65, w_65);
                                  term = gt$S_0_0.instance.invoke(context, term);
                                  if(term == null)
                                    break Fail246;
                                  term = termFactory.makeAppl(Simplify._consLt_2, new IStrategoTerm[]{u_65, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{v_65})});
                                  if(true)
                                    break Success191;
                                }
                                term = term390;
                              }
                              Success192:
                              { 
                                if(cons36 == Simplify._consOr_2)
                                { 
                                  Fail247:
                                  { 
                                    IStrategoTerm p_65 = null;
                                    IStrategoTerm q_65 = null;
                                    IStrategoTerm r_65 = null;
                                    IStrategoTerm arg655 = term.getSubterm(0);
                                    if(arg655.getTermType() != IStrategoTerm.APPL || Simplify._consLeq_2 != ((IStrategoAppl)arg655).getConstructor())
                                      break Fail247;
                                    p_65 = arg655.getSubterm(0);
                                    IStrategoTerm arg656 = arg655.getSubterm(1);
                                    if(arg656.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg656).getConstructor())
                                      break Fail247;
                                    q_65 = arg656.getSubterm(0);
                                    IStrategoTerm arg657 = term.getSubterm(1);
                                    if(arg657.getTermType() != IStrategoTerm.APPL || Simplify._consLeq_2 != ((IStrategoAppl)arg657).getConstructor())
                                      break Fail247;
                                    if(arg657.getSubterm(0) != p_65 && !p_65.match(arg657.getSubterm(0)))
                                      break Fail247;
                                    IStrategoTerm arg658 = arg657.getSubterm(1);
                                    if(arg658.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg658).getConstructor())
                                      break Fail247;
                                    r_65 = arg658.getSubterm(0);
                                    term = termFactory.makeTuple(q_65, r_65);
                                    term = maxstring_0_0.instance.invoke(context, term);
                                    if(term == null)
                                      break Fail247;
                                    term = termFactory.makeAppl(Simplify._consLeq_2, new IStrategoTerm[]{p_65, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{term})});
                                    if(true)
                                      break Success192;
                                  }
                                  term = term390;
                                }
                                Success193:
                                { 
                                  if(cons36 == Simplify._consOr_2)
                                  { 
                                    Fail248:
                                    { 
                                      IStrategoTerm n_65 = null;
                                      IStrategoTerm o_65 = null;
                                      IStrategoTerm arg659 = term.getSubterm(0);
                                      if(arg659.getTermType() != IStrategoTerm.APPL || Simplify._consEqu_2 != ((IStrategoAppl)arg659).getConstructor())
                                        break Fail248;
                                      n_65 = arg659.getSubterm(0);
                                      IStrategoTerm arg660 = arg659.getSubterm(1);
                                      if(arg660.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg660).getConstructor())
                                        break Fail248;
                                      o_65 = arg660.getSubterm(0);
                                      IStrategoTerm arg661 = term.getSubterm(1);
                                      if(arg661.getTermType() != IStrategoTerm.APPL || Simplify._consEqu_2 != ((IStrategoAppl)arg661).getConstructor())
                                        break Fail248;
                                      if(arg661.getSubterm(0) != n_65 && !n_65.match(arg661.getSubterm(0)))
                                        break Fail248;
                                      IStrategoTerm arg662 = arg661.getSubterm(1);
                                      if(arg662.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg662).getConstructor())
                                        break Fail248;
                                      if(arg662.getSubterm(0) != o_65 && !o_65.match(arg662.getSubterm(0)))
                                        break Fail248;
                                      term = termFactory.makeAppl(Simplify._consEqu_2, new IStrategoTerm[]{n_65, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{o_65})});
                                      if(true)
                                        break Success193;
                                    }
                                    term = term390;
                                  }
                                  Success194:
                                  { 
                                    if(cons36 == Simplify._consOr_2)
                                    { 
                                      Fail249:
                                      { 
                                        IStrategoTerm i_65 = null;
                                        IStrategoTerm j_65 = null;
                                        IStrategoTerm k_65 = null;
                                        IStrategoTerm arg663 = term.getSubterm(0);
                                        if(arg663.getTermType() != IStrategoTerm.APPL || Simplify._consGeq_2 != ((IStrategoAppl)arg663).getConstructor())
                                          break Fail249;
                                        i_65 = arg663.getSubterm(0);
                                        IStrategoTerm arg664 = arg663.getSubterm(1);
                                        if(arg664.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg664).getConstructor())
                                          break Fail249;
                                        j_65 = arg664.getSubterm(0);
                                        IStrategoTerm arg665 = term.getSubterm(1);
                                        if(arg665.getTermType() != IStrategoTerm.APPL || Simplify._consGeq_2 != ((IStrategoAppl)arg665).getConstructor())
                                          break Fail249;
                                        if(arg665.getSubterm(0) != i_65 && !i_65.match(arg665.getSubterm(0)))
                                          break Fail249;
                                        IStrategoTerm arg666 = arg665.getSubterm(1);
                                        if(arg666.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg666).getConstructor())
                                          break Fail249;
                                        k_65 = arg666.getSubterm(0);
                                        term = termFactory.makeTuple(j_65, k_65);
                                        term = minstring_0_0.instance.invoke(context, term);
                                        if(term == null)
                                          break Fail249;
                                        term = termFactory.makeAppl(Simplify._consGeq_2, new IStrategoTerm[]{i_65, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{term})});
                                        if(true)
                                          break Success194;
                                      }
                                      term = term390;
                                    }
                                    Success195:
                                    { 
                                      if(cons36 == Simplify._consOr_2)
                                      { 
                                        Fail250:
                                        { 
                                          IStrategoTerm e_65 = null;
                                          IStrategoTerm f_65 = null;
                                          IStrategoTerm g_65 = null;
                                          IStrategoTerm arg667 = term.getSubterm(0);
                                          if(arg667.getTermType() != IStrategoTerm.APPL || Simplify._consGeq_2 != ((IStrategoAppl)arg667).getConstructor())
                                            break Fail250;
                                          e_65 = arg667.getSubterm(0);
                                          IStrategoTerm arg668 = arg667.getSubterm(1);
                                          if(arg668.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg668).getConstructor())
                                            break Fail250;
                                          f_65 = arg668.getSubterm(0);
                                          IStrategoTerm arg669 = term.getSubterm(1);
                                          if(arg669.getTermType() != IStrategoTerm.APPL || Simplify._consGt_2 != ((IStrategoAppl)arg669).getConstructor())
                                            break Fail250;
                                          if(arg669.getSubterm(0) != e_65 && !e_65.match(arg669.getSubterm(0)))
                                            break Fail250;
                                          IStrategoTerm arg670 = arg669.getSubterm(1);
                                          if(arg670.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg670).getConstructor())
                                            break Fail250;
                                          g_65 = arg670.getSubterm(0);
                                          term = termFactory.makeTuple(f_65, g_65);
                                          term = leq$S_0_0.instance.invoke(context, term);
                                          if(term == null)
                                            break Fail250;
                                          term = termFactory.makeAppl(Simplify._consGeq_2, new IStrategoTerm[]{e_65, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{f_65})});
                                          if(true)
                                            break Success195;
                                        }
                                        term = term390;
                                      }
                                      Success196:
                                      { 
                                        if(cons36 == Simplify._consOr_2)
                                        { 
                                          Fail251:
                                          { 
                                            IStrategoTerm a_65 = null;
                                            IStrategoTerm b_65 = null;
                                            IStrategoTerm c_65 = null;
                                            IStrategoTerm arg671 = term.getSubterm(0);
                                            if(arg671.getTermType() != IStrategoTerm.APPL || Simplify._consGeq_2 != ((IStrategoAppl)arg671).getConstructor())
                                              break Fail251;
                                            a_65 = arg671.getSubterm(0);
                                            IStrategoTerm arg672 = arg671.getSubterm(1);
                                            if(arg672.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg672).getConstructor())
                                              break Fail251;
                                            b_65 = arg672.getSubterm(0);
                                            IStrategoTerm arg673 = term.getSubterm(1);
                                            if(arg673.getTermType() != IStrategoTerm.APPL || Simplify._consGt_2 != ((IStrategoAppl)arg673).getConstructor())
                                              break Fail251;
                                            if(arg673.getSubterm(0) != a_65 && !a_65.match(arg673.getSubterm(0)))
                                              break Fail251;
                                            IStrategoTerm arg674 = arg673.getSubterm(1);
                                            if(arg674.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg674).getConstructor())
                                              break Fail251;
                                            c_65 = arg674.getSubterm(0);
                                            term = termFactory.makeTuple(b_65, c_65);
                                            term = gt$S_0_0.instance.invoke(context, term);
                                            if(term == null)
                                              break Fail251;
                                            term = termFactory.makeAppl(Simplify._consGt_2, new IStrategoTerm[]{a_65, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{c_65})});
                                            if(true)
                                              break Success196;
                                          }
                                          term = term390;
                                        }
                                        Success197:
                                        { 
                                          if(cons36 == Simplify._consOr_2)
                                          { 
                                            Fail252:
                                            { 
                                              IStrategoTerm u_64 = null;
                                              IStrategoTerm v_64 = null;
                                              IStrategoTerm x_64 = null;
                                              IStrategoTerm arg675 = term.getSubterm(0);
                                              if(arg675.getTermType() != IStrategoTerm.APPL || Simplify._consGt_2 != ((IStrategoAppl)arg675).getConstructor())
                                                break Fail252;
                                              u_64 = arg675.getSubterm(0);
                                              IStrategoTerm arg676 = arg675.getSubterm(1);
                                              if(arg676.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg676).getConstructor())
                                                break Fail252;
                                              v_64 = arg676.getSubterm(0);
                                              IStrategoTerm arg677 = term.getSubterm(1);
                                              if(arg677.getTermType() != IStrategoTerm.APPL || Simplify._consGt_2 != ((IStrategoAppl)arg677).getConstructor())
                                                break Fail252;
                                              if(arg677.getSubterm(0) != u_64 && !u_64.match(arg677.getSubterm(0)))
                                                break Fail252;
                                              IStrategoTerm arg678 = arg677.getSubterm(1);
                                              if(arg678.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg678).getConstructor())
                                                break Fail252;
                                              x_64 = arg678.getSubterm(0);
                                              term = termFactory.makeTuple(v_64, x_64);
                                              term = minstring_0_0.instance.invoke(context, term);
                                              if(term == null)
                                                break Fail252;
                                              term = termFactory.makeAppl(Simplify._consGt_2, new IStrategoTerm[]{u_64, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{term})});
                                              if(true)
                                                break Success197;
                                            }
                                            term = term390;
                                          }
                                          Success198:
                                          { 
                                            if(cons36 == Simplify._consOr_2)
                                            { 
                                              Fail253:
                                              { 
                                                IStrategoTerm o_64 = null;
                                                IStrategoTerm p_64 = null;
                                                IStrategoTerm q_64 = null;
                                                IStrategoTerm r_64 = null;
                                                IStrategoTerm arg679 = term.getSubterm(0);
                                                if(arg679.getTermType() != IStrategoTerm.APPL || Simplify._consOr_2 != ((IStrategoAppl)arg679).getConstructor())
                                                  break Fail253;
                                                o_64 = arg679.getSubterm(0);
                                                IStrategoTerm arg680 = arg679.getSubterm(1);
                                                if(arg680.getTermType() != IStrategoTerm.APPL || Simplify._consLt_2 != ((IStrategoAppl)arg680).getConstructor())
                                                  break Fail253;
                                                p_64 = arg680.getSubterm(0);
                                                IStrategoTerm arg681 = arg680.getSubterm(1);
                                                if(arg681.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg681).getConstructor())
                                                  break Fail253;
                                                q_64 = arg681.getSubterm(0);
                                                IStrategoTerm arg682 = term.getSubterm(1);
                                                if(arg682.getTermType() != IStrategoTerm.APPL || Simplify._consLt_2 != ((IStrategoAppl)arg682).getConstructor())
                                                  break Fail253;
                                                if(arg682.getSubterm(0) != p_64 && !p_64.match(arg682.getSubterm(0)))
                                                  break Fail253;
                                                IStrategoTerm arg683 = arg682.getSubterm(1);
                                                if(arg683.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg683).getConstructor())
                                                  break Fail253;
                                                r_64 = arg683.getSubterm(0);
                                                term = termFactory.makeTuple(q_64, r_64);
                                                term = maxstring_0_0.instance.invoke(context, term);
                                                if(term == null)
                                                  break Fail253;
                                                term = termFactory.makeAppl(Simplify._consOr_2, new IStrategoTerm[]{o_64, termFactory.makeAppl(Simplify._consLt_2, new IStrategoTerm[]{p_64, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{term})})});
                                                if(true)
                                                  break Success198;
                                              }
                                              term = term390;
                                            }
                                            Success199:
                                            { 
                                              if(cons36 == Simplify._consOr_2)
                                              { 
                                                Fail254:
                                                { 
                                                  IStrategoTerm j_64 = null;
                                                  IStrategoTerm k_64 = null;
                                                  IStrategoTerm l_64 = null;
                                                  IStrategoTerm m_64 = null;
                                                  IStrategoTerm arg684 = term.getSubterm(0);
                                                  if(arg684.getTermType() != IStrategoTerm.APPL || Simplify._consOr_2 != ((IStrategoAppl)arg684).getConstructor())
                                                    break Fail254;
                                                  j_64 = arg684.getSubterm(0);
                                                  IStrategoTerm arg685 = arg684.getSubterm(1);
                                                  if(arg685.getTermType() != IStrategoTerm.APPL || Simplify._consLt_2 != ((IStrategoAppl)arg685).getConstructor())
                                                    break Fail254;
                                                  k_64 = arg685.getSubterm(0);
                                                  IStrategoTerm arg686 = arg685.getSubterm(1);
                                                  if(arg686.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg686).getConstructor())
                                                    break Fail254;
                                                  l_64 = arg686.getSubterm(0);
                                                  IStrategoTerm arg687 = term.getSubterm(1);
                                                  if(arg687.getTermType() != IStrategoTerm.APPL || Simplify._consLeq_2 != ((IStrategoAppl)arg687).getConstructor())
                                                    break Fail254;
                                                  if(arg687.getSubterm(0) != k_64 && !k_64.match(arg687.getSubterm(0)))
                                                    break Fail254;
                                                  IStrategoTerm arg688 = arg687.getSubterm(1);
                                                  if(arg688.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg688).getConstructor())
                                                    break Fail254;
                                                  m_64 = arg688.getSubterm(0);
                                                  term = termFactory.makeTuple(l_64, m_64);
                                                  term = leq$S_0_0.instance.invoke(context, term);
                                                  if(term == null)
                                                    break Fail254;
                                                  term = termFactory.makeAppl(Simplify._consOr_2, new IStrategoTerm[]{j_64, termFactory.makeAppl(Simplify._consLeq_2, new IStrategoTerm[]{k_64, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{m_64})})});
                                                  if(true)
                                                    break Success199;
                                                }
                                                term = term390;
                                              }
                                              Success200:
                                              { 
                                                if(cons36 == Simplify._consOr_2)
                                                { 
                                                  Fail255:
                                                  { 
                                                    IStrategoTerm e_64 = null;
                                                    IStrategoTerm f_64 = null;
                                                    IStrategoTerm g_64 = null;
                                                    IStrategoTerm h_64 = null;
                                                    IStrategoTerm arg689 = term.getSubterm(0);
                                                    if(arg689.getTermType() != IStrategoTerm.APPL || Simplify._consOr_2 != ((IStrategoAppl)arg689).getConstructor())
                                                      break Fail255;
                                                    e_64 = arg689.getSubterm(0);
                                                    IStrategoTerm arg690 = arg689.getSubterm(1);
                                                    if(arg690.getTermType() != IStrategoTerm.APPL || Simplify._consLt_2 != ((IStrategoAppl)arg690).getConstructor())
                                                      break Fail255;
                                                    f_64 = arg690.getSubterm(0);
                                                    IStrategoTerm arg691 = arg690.getSubterm(1);
                                                    if(arg691.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg691).getConstructor())
                                                      break Fail255;
                                                    g_64 = arg691.getSubterm(0);
                                                    IStrategoTerm arg692 = term.getSubterm(1);
                                                    if(arg692.getTermType() != IStrategoTerm.APPL || Simplify._consLeq_2 != ((IStrategoAppl)arg692).getConstructor())
                                                      break Fail255;
                                                    if(arg692.getSubterm(0) != f_64 && !f_64.match(arg692.getSubterm(0)))
                                                      break Fail255;
                                                    IStrategoTerm arg693 = arg692.getSubterm(1);
                                                    if(arg693.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg693).getConstructor())
                                                      break Fail255;
                                                    h_64 = arg693.getSubterm(0);
                                                    term = termFactory.makeTuple(g_64, h_64);
                                                    term = gt$S_0_0.instance.invoke(context, term);
                                                    if(term == null)
                                                      break Fail255;
                                                    term = termFactory.makeAppl(Simplify._consOr_2, new IStrategoTerm[]{e_64, termFactory.makeAppl(Simplify._consLt_2, new IStrategoTerm[]{f_64, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{g_64})})});
                                                    if(true)
                                                      break Success200;
                                                  }
                                                  term = term390;
                                                }
                                                Success201:
                                                { 
                                                  if(cons36 == Simplify._consOr_2)
                                                  { 
                                                    Fail256:
                                                    { 
                                                      IStrategoTerm y_63 = null;
                                                      IStrategoTerm z_63 = null;
                                                      IStrategoTerm a_64 = null;
                                                      IStrategoTerm b_64 = null;
                                                      IStrategoTerm arg694 = term.getSubterm(0);
                                                      if(arg694.getTermType() != IStrategoTerm.APPL || Simplify._consOr_2 != ((IStrategoAppl)arg694).getConstructor())
                                                        break Fail256;
                                                      y_63 = arg694.getSubterm(0);
                                                      IStrategoTerm arg695 = arg694.getSubterm(1);
                                                      if(arg695.getTermType() != IStrategoTerm.APPL || Simplify._consLeq_2 != ((IStrategoAppl)arg695).getConstructor())
                                                        break Fail256;
                                                      z_63 = arg695.getSubterm(0);
                                                      IStrategoTerm arg696 = arg695.getSubterm(1);
                                                      if(arg696.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg696).getConstructor())
                                                        break Fail256;
                                                      a_64 = arg696.getSubterm(0);
                                                      IStrategoTerm arg697 = term.getSubterm(1);
                                                      if(arg697.getTermType() != IStrategoTerm.APPL || Simplify._consLeq_2 != ((IStrategoAppl)arg697).getConstructor())
                                                        break Fail256;
                                                      if(arg697.getSubterm(0) != z_63 && !z_63.match(arg697.getSubterm(0)))
                                                        break Fail256;
                                                      IStrategoTerm arg698 = arg697.getSubterm(1);
                                                      if(arg698.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg698).getConstructor())
                                                        break Fail256;
                                                      b_64 = arg698.getSubterm(0);
                                                      term = termFactory.makeTuple(a_64, b_64);
                                                      term = maxstring_0_0.instance.invoke(context, term);
                                                      if(term == null)
                                                        break Fail256;
                                                      term = termFactory.makeAppl(Simplify._consOr_2, new IStrategoTerm[]{y_63, termFactory.makeAppl(Simplify._consLeq_2, new IStrategoTerm[]{z_63, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{term})})});
                                                      if(true)
                                                        break Success201;
                                                    }
                                                    term = term390;
                                                  }
                                                  Success202:
                                                  { 
                                                    if(cons36 == Simplify._consOr_2)
                                                    { 
                                                      Fail257:
                                                      { 
                                                        IStrategoTerm v_63 = null;
                                                        IStrategoTerm w_63 = null;
                                                        IStrategoTerm x_63 = null;
                                                        IStrategoTerm arg699 = term.getSubterm(0);
                                                        if(arg699.getTermType() != IStrategoTerm.APPL || Simplify._consOr_2 != ((IStrategoAppl)arg699).getConstructor())
                                                          break Fail257;
                                                        v_63 = arg699.getSubterm(0);
                                                        IStrategoTerm arg700 = arg699.getSubterm(1);
                                                        if(arg700.getTermType() != IStrategoTerm.APPL || Simplify._consEqu_2 != ((IStrategoAppl)arg700).getConstructor())
                                                          break Fail257;
                                                        w_63 = arg700.getSubterm(0);
                                                        IStrategoTerm arg701 = arg700.getSubterm(1);
                                                        if(arg701.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg701).getConstructor())
                                                          break Fail257;
                                                        x_63 = arg701.getSubterm(0);
                                                        IStrategoTerm arg702 = term.getSubterm(1);
                                                        if(arg702.getTermType() != IStrategoTerm.APPL || Simplify._consEqu_2 != ((IStrategoAppl)arg702).getConstructor())
                                                          break Fail257;
                                                        if(arg702.getSubterm(0) != w_63 && !w_63.match(arg702.getSubterm(0)))
                                                          break Fail257;
                                                        IStrategoTerm arg703 = arg702.getSubterm(1);
                                                        if(arg703.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg703).getConstructor())
                                                          break Fail257;
                                                        if(arg703.getSubterm(0) != x_63 && !x_63.match(arg703.getSubterm(0)))
                                                          break Fail257;
                                                        term = termFactory.makeAppl(Simplify._consOr_2, new IStrategoTerm[]{v_63, termFactory.makeAppl(Simplify._consEqu_2, new IStrategoTerm[]{w_63, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{x_63})})});
                                                        if(true)
                                                          break Success202;
                                                      }
                                                      term = term390;
                                                    }
                                                    Success203:
                                                    { 
                                                      if(cons36 == Simplify._consOr_2)
                                                      { 
                                                        Fail258:
                                                        { 
                                                          IStrategoTerm p_63 = null;
                                                          IStrategoTerm q_63 = null;
                                                          IStrategoTerm r_63 = null;
                                                          IStrategoTerm s_63 = null;
                                                          IStrategoTerm arg704 = term.getSubterm(0);
                                                          if(arg704.getTermType() != IStrategoTerm.APPL || Simplify._consOr_2 != ((IStrategoAppl)arg704).getConstructor())
                                                            break Fail258;
                                                          p_63 = arg704.getSubterm(0);
                                                          IStrategoTerm arg705 = arg704.getSubterm(1);
                                                          if(arg705.getTermType() != IStrategoTerm.APPL || Simplify._consGeq_2 != ((IStrategoAppl)arg705).getConstructor())
                                                            break Fail258;
                                                          q_63 = arg705.getSubterm(0);
                                                          IStrategoTerm arg706 = arg705.getSubterm(1);
                                                          if(arg706.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg706).getConstructor())
                                                            break Fail258;
                                                          r_63 = arg706.getSubterm(0);
                                                          IStrategoTerm arg707 = term.getSubterm(1);
                                                          if(arg707.getTermType() != IStrategoTerm.APPL || Simplify._consGeq_2 != ((IStrategoAppl)arg707).getConstructor())
                                                            break Fail258;
                                                          if(arg707.getSubterm(0) != q_63 && !q_63.match(arg707.getSubterm(0)))
                                                            break Fail258;
                                                          IStrategoTerm arg708 = arg707.getSubterm(1);
                                                          if(arg708.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg708).getConstructor())
                                                            break Fail258;
                                                          s_63 = arg708.getSubterm(0);
                                                          term = termFactory.makeTuple(r_63, s_63);
                                                          term = minstring_0_0.instance.invoke(context, term);
                                                          if(term == null)
                                                            break Fail258;
                                                          term = termFactory.makeAppl(Simplify._consOr_2, new IStrategoTerm[]{p_63, termFactory.makeAppl(Simplify._consGeq_2, new IStrategoTerm[]{q_63, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{term})})});
                                                          if(true)
                                                            break Success203;
                                                        }
                                                        term = term390;
                                                      }
                                                      Success204:
                                                      { 
                                                        if(cons36 == Simplify._consOr_2)
                                                        { 
                                                          Fail259:
                                                          { 
                                                            IStrategoTerm k_63 = null;
                                                            IStrategoTerm l_63 = null;
                                                            IStrategoTerm m_63 = null;
                                                            IStrategoTerm n_63 = null;
                                                            IStrategoTerm arg709 = term.getSubterm(0);
                                                            if(arg709.getTermType() != IStrategoTerm.APPL || Simplify._consOr_2 != ((IStrategoAppl)arg709).getConstructor())
                                                              break Fail259;
                                                            k_63 = arg709.getSubterm(0);
                                                            IStrategoTerm arg710 = arg709.getSubterm(1);
                                                            if(arg710.getTermType() != IStrategoTerm.APPL || Simplify._consGeq_2 != ((IStrategoAppl)arg710).getConstructor())
                                                              break Fail259;
                                                            l_63 = arg710.getSubterm(0);
                                                            IStrategoTerm arg711 = arg710.getSubterm(1);
                                                            if(arg711.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg711).getConstructor())
                                                              break Fail259;
                                                            m_63 = arg711.getSubterm(0);
                                                            IStrategoTerm arg712 = term.getSubterm(1);
                                                            if(arg712.getTermType() != IStrategoTerm.APPL || Simplify._consGt_2 != ((IStrategoAppl)arg712).getConstructor())
                                                              break Fail259;
                                                            if(arg712.getSubterm(0) != l_63 && !l_63.match(arg712.getSubterm(0)))
                                                              break Fail259;
                                                            IStrategoTerm arg713 = arg712.getSubterm(1);
                                                            if(arg713.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg713).getConstructor())
                                                              break Fail259;
                                                            n_63 = arg713.getSubterm(0);
                                                            term = termFactory.makeTuple(m_63, n_63);
                                                            term = leq$S_0_0.instance.invoke(context, term);
                                                            if(term == null)
                                                              break Fail259;
                                                            term = termFactory.makeAppl(Simplify._consOr_2, new IStrategoTerm[]{k_63, termFactory.makeAppl(Simplify._consGeq_2, new IStrategoTerm[]{l_63, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{m_63})})});
                                                            if(true)
                                                              break Success204;
                                                          }
                                                          term = term390;
                                                        }
                                                        Success205:
                                                        { 
                                                          if(cons36 == Simplify._consOr_2)
                                                          { 
                                                            Fail260:
                                                            { 
                                                              IStrategoTerm d_63 = null;
                                                              IStrategoTerm e_63 = null;
                                                              IStrategoTerm f_63 = null;
                                                              IStrategoTerm i_63 = null;
                                                              IStrategoTerm arg714 = term.getSubterm(0);
                                                              if(arg714.getTermType() != IStrategoTerm.APPL || Simplify._consOr_2 != ((IStrategoAppl)arg714).getConstructor())
                                                                break Fail260;
                                                              d_63 = arg714.getSubterm(0);
                                                              IStrategoTerm arg715 = arg714.getSubterm(1);
                                                              if(arg715.getTermType() != IStrategoTerm.APPL || Simplify._consGeq_2 != ((IStrategoAppl)arg715).getConstructor())
                                                                break Fail260;
                                                              e_63 = arg715.getSubterm(0);
                                                              IStrategoTerm arg716 = arg715.getSubterm(1);
                                                              if(arg716.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg716).getConstructor())
                                                                break Fail260;
                                                              f_63 = arg716.getSubterm(0);
                                                              IStrategoTerm arg717 = term.getSubterm(1);
                                                              if(arg717.getTermType() != IStrategoTerm.APPL || Simplify._consGt_2 != ((IStrategoAppl)arg717).getConstructor())
                                                                break Fail260;
                                                              if(arg717.getSubterm(0) != e_63 && !e_63.match(arg717.getSubterm(0)))
                                                                break Fail260;
                                                              IStrategoTerm arg718 = arg717.getSubterm(1);
                                                              if(arg718.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg718).getConstructor())
                                                                break Fail260;
                                                              i_63 = arg718.getSubterm(0);
                                                              term = termFactory.makeTuple(f_63, i_63);
                                                              term = gt$S_0_0.instance.invoke(context, term);
                                                              if(term == null)
                                                                break Fail260;
                                                              term = termFactory.makeAppl(Simplify._consOr_2, new IStrategoTerm[]{d_63, termFactory.makeAppl(Simplify._consGt_2, new IStrategoTerm[]{e_63, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{i_63})})});
                                                              if(true)
                                                                break Success205;
                                                            }
                                                            term = term390;
                                                          }
                                                          if(cons36 == Simplify._consOr_2)
                                                          { 
                                                            IStrategoTerm x_62 = null;
                                                            IStrategoTerm y_62 = null;
                                                            IStrategoTerm z_62 = null;
                                                            IStrategoTerm a_63 = null;
                                                            IStrategoTerm arg719 = term.getSubterm(0);
                                                            if(arg719.getTermType() != IStrategoTerm.APPL || Simplify._consOr_2 != ((IStrategoAppl)arg719).getConstructor())
                                                              break Fail234;
                                                            x_62 = arg719.getSubterm(0);
                                                            IStrategoTerm arg720 = arg719.getSubterm(1);
                                                            if(arg720.getTermType() != IStrategoTerm.APPL || Simplify._consGt_2 != ((IStrategoAppl)arg720).getConstructor())
                                                              break Fail234;
                                                            y_62 = arg720.getSubterm(0);
                                                            IStrategoTerm arg721 = arg720.getSubterm(1);
                                                            if(arg721.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg721).getConstructor())
                                                              break Fail234;
                                                            z_62 = arg721.getSubterm(0);
                                                            IStrategoTerm arg722 = term.getSubterm(1);
                                                            if(arg722.getTermType() != IStrategoTerm.APPL || Simplify._consGt_2 != ((IStrategoAppl)arg722).getConstructor())
                                                              break Fail234;
                                                            if(arg722.getSubterm(0) != y_62 && !y_62.match(arg722.getSubterm(0)))
                                                              break Fail234;
                                                            IStrategoTerm arg723 = arg722.getSubterm(1);
                                                            if(arg723.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg723).getConstructor())
                                                              break Fail234;
                                                            a_63 = arg723.getSubterm(0);
                                                            term = termFactory.makeTuple(z_62, a_63);
                                                            term = minstring_0_0.instance.invoke(context, term);
                                                            if(term == null)
                                                              break Fail234;
                                                            term = termFactory.makeAppl(Simplify._consOr_2, new IStrategoTerm[]{x_62, termFactory.makeAppl(Simplify._consGt_2, new IStrategoTerm[]{y_62, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{term})})});
                                                          }
                                                          else
                                                          { 
                                                            break Fail234;
                                                          }
                                                        }
                                                      }
                                                    }
                                                  }
                                                }
                                              }
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class $Merge$Compare_0_0 extends Strategy 
  { 
    public static $Merge$Compare_0_0 instance = new $Merge$Compare_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      ITermFactory termFactory = context.getFactory();
      context.push("MergeCompare_0_0");
      Fail261:
      { 
        IStrategoTerm term416 = term;
        IStrategoConstructor cons37 = term.getTermType() == IStrategoTerm.APPL ? ((IStrategoAppl)term).getConstructor() : null;
        Success206:
        { 
          if(cons37 == Simplify._consAnd_2)
          { 
            Fail262:
            { 
              IStrategoTerm h_72 = null;
              IStrategoTerm i_72 = null;
              IStrategoTerm j_72 = null;
              IStrategoTerm arg724 = term.getSubterm(0);
              if(arg724.getTermType() != IStrategoTerm.APPL || Simplify._consLt_2 != ((IStrategoAppl)arg724).getConstructor())
                break Fail262;
              h_72 = arg724.getSubterm(0);
              IStrategoTerm arg725 = arg724.getSubterm(1);
              if(arg725.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg725).getConstructor())
                break Fail262;
              i_72 = arg725.getSubterm(0);
              IStrategoTerm arg726 = term.getSubterm(1);
              if(arg726.getTermType() != IStrategoTerm.APPL || Simplify._consLt_2 != ((IStrategoAppl)arg726).getConstructor())
                break Fail262;
              if(arg726.getSubterm(0) != h_72 && !h_72.match(arg726.getSubterm(0)))
                break Fail262;
              IStrategoTerm arg727 = arg726.getSubterm(1);
              if(arg727.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg727).getConstructor())
                break Fail262;
              j_72 = arg727.getSubterm(0);
              term = termFactory.makeTuple(i_72, j_72);
              term = minstring_0_0.instance.invoke(context, term);
              if(term == null)
                break Fail262;
              term = termFactory.makeAppl(Simplify._consLt_2, new IStrategoTerm[]{h_72, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{term})});
              if(true)
                break Success206;
            }
            term = term416;
          }
          Success207:
          { 
            if(cons37 == Simplify._consAnd_2)
            { 
              Fail263:
              { 
                IStrategoTerm d_72 = null;
                IStrategoTerm e_72 = null;
                IStrategoTerm f_72 = null;
                IStrategoTerm arg728 = term.getSubterm(0);
                if(arg728.getTermType() != IStrategoTerm.APPL || Simplify._consLt_2 != ((IStrategoAppl)arg728).getConstructor())
                  break Fail263;
                d_72 = arg728.getSubterm(0);
                IStrategoTerm arg729 = arg728.getSubterm(1);
                if(arg729.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg729).getConstructor())
                  break Fail263;
                e_72 = arg729.getSubterm(0);
                IStrategoTerm arg730 = term.getSubterm(1);
                if(arg730.getTermType() != IStrategoTerm.APPL || Simplify._consLeq_2 != ((IStrategoAppl)arg730).getConstructor())
                  break Fail263;
                if(arg730.getSubterm(0) != d_72 && !d_72.match(arg730.getSubterm(0)))
                  break Fail263;
                IStrategoTerm arg731 = arg730.getSubterm(1);
                if(arg731.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg731).getConstructor())
                  break Fail263;
                f_72 = arg731.getSubterm(0);
                term = termFactory.makeTuple(e_72, f_72);
                term = gt$S_0_0.instance.invoke(context, term);
                if(term == null)
                  break Fail263;
                term = termFactory.makeAppl(Simplify._consLeq_2, new IStrategoTerm[]{d_72, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{f_72})});
                if(true)
                  break Success207;
              }
              term = term416;
            }
            Success208:
            { 
              if(cons37 == Simplify._consAnd_2)
              { 
                Fail264:
                { 
                  IStrategoTerm z_71 = null;
                  IStrategoTerm a_72 = null;
                  IStrategoTerm b_72 = null;
                  IStrategoTerm arg732 = term.getSubterm(0);
                  if(arg732.getTermType() != IStrategoTerm.APPL || Simplify._consLt_2 != ((IStrategoAppl)arg732).getConstructor())
                    break Fail264;
                  z_71 = arg732.getSubterm(0);
                  IStrategoTerm arg733 = arg732.getSubterm(1);
                  if(arg733.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg733).getConstructor())
                    break Fail264;
                  a_72 = arg733.getSubterm(0);
                  IStrategoTerm arg734 = term.getSubterm(1);
                  if(arg734.getTermType() != IStrategoTerm.APPL || Simplify._consLeq_2 != ((IStrategoAppl)arg734).getConstructor())
                    break Fail264;
                  if(arg734.getSubterm(0) != z_71 && !z_71.match(arg734.getSubterm(0)))
                    break Fail264;
                  IStrategoTerm arg735 = arg734.getSubterm(1);
                  if(arg735.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg735).getConstructor())
                    break Fail264;
                  b_72 = arg735.getSubterm(0);
                  term = termFactory.makeTuple(a_72, b_72);
                  term = leq$S_0_0.instance.invoke(context, term);
                  if(term == null)
                    break Fail264;
                  term = termFactory.makeAppl(Simplify._consLt_2, new IStrategoTerm[]{z_71, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{a_72})});
                  if(true)
                    break Success208;
                }
                term = term416;
              }
              Success209:
              { 
                if(cons37 == Simplify._consAnd_2)
                { 
                  Fail265:
                  { 
                    IStrategoTerm u_71 = null;
                    IStrategoTerm v_71 = null;
                    IStrategoTerm w_71 = null;
                    IStrategoTerm arg736 = term.getSubterm(0);
                    if(arg736.getTermType() != IStrategoTerm.APPL || Simplify._consLeq_2 != ((IStrategoAppl)arg736).getConstructor())
                      break Fail265;
                    u_71 = arg736.getSubterm(0);
                    IStrategoTerm arg737 = arg736.getSubterm(1);
                    if(arg737.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg737).getConstructor())
                      break Fail265;
                    v_71 = arg737.getSubterm(0);
                    IStrategoTerm arg738 = term.getSubterm(1);
                    if(arg738.getTermType() != IStrategoTerm.APPL || Simplify._consLeq_2 != ((IStrategoAppl)arg738).getConstructor())
                      break Fail265;
                    if(arg738.getSubterm(0) != u_71 && !u_71.match(arg738.getSubterm(0)))
                      break Fail265;
                    IStrategoTerm arg739 = arg738.getSubterm(1);
                    if(arg739.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg739).getConstructor())
                      break Fail265;
                    w_71 = arg739.getSubterm(0);
                    term = termFactory.makeTuple(v_71, w_71);
                    term = minstring_0_0.instance.invoke(context, term);
                    if(term == null)
                      break Fail265;
                    term = termFactory.makeAppl(Simplify._consLeq_2, new IStrategoTerm[]{u_71, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{term})});
                    if(true)
                      break Success209;
                  }
                  term = term416;
                }
                Success210:
                { 
                  if(cons37 == Simplify._consAnd_2)
                  { 
                    Fail266:
                    { 
                      IStrategoTerm q_71 = null;
                      IStrategoTerm r_71 = null;
                      IStrategoTerm s_71 = null;
                      IStrategoTerm arg740 = term.getSubterm(0);
                      if(arg740.getTermType() != IStrategoTerm.APPL || Simplify._consEqu_2 != ((IStrategoAppl)arg740).getConstructor())
                        break Fail266;
                      q_71 = arg740.getSubterm(0);
                      IStrategoTerm arg741 = arg740.getSubterm(1);
                      if(arg741.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg741).getConstructor())
                        break Fail266;
                      r_71 = arg741.getSubterm(0);
                      IStrategoTerm arg742 = term.getSubterm(1);
                      if(arg742.getTermType() != IStrategoTerm.APPL || Simplify._consEqu_2 != ((IStrategoAppl)arg742).getConstructor())
                        break Fail266;
                      if(arg742.getSubterm(0) != q_71 && !q_71.match(arg742.getSubterm(0)))
                        break Fail266;
                      IStrategoTerm arg743 = arg742.getSubterm(1);
                      if(arg743.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg743).getConstructor())
                        break Fail266;
                      s_71 = arg743.getSubterm(0);
                      term = termFactory.makeTuple(r_71, s_71);
                      IStrategoTerm term421 = term;
                      Success211:
                      { 
                        Fail267:
                        { 
                          term = eq_0_0.instance.invoke(context, term);
                          if(term == null)
                            break Fail267;
                          { 
                            if(true)
                              break Fail266;
                            if(true)
                              break Success211;
                          }
                        }
                        term = term421;
                      }
                      term = Simplify.constFalse0;
                      if(true)
                        break Success210;
                    }
                    term = term416;
                  }
                  Success212:
                  { 
                    if(cons37 == Simplify._consAnd_2)
                    { 
                      Fail268:
                      { 
                        IStrategoTerm m_71 = null;
                        IStrategoTerm n_71 = null;
                        IStrategoTerm arg744 = term.getSubterm(0);
                        if(arg744.getTermType() != IStrategoTerm.APPL || Simplify._consEqu_2 != ((IStrategoAppl)arg744).getConstructor())
                          break Fail268;
                        m_71 = arg744.getSubterm(0);
                        IStrategoTerm arg745 = arg744.getSubterm(1);
                        if(arg745.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg745).getConstructor())
                          break Fail268;
                        n_71 = arg745.getSubterm(0);
                        IStrategoTerm arg746 = term.getSubterm(1);
                        if(arg746.getTermType() != IStrategoTerm.APPL || Simplify._consEqu_2 != ((IStrategoAppl)arg746).getConstructor())
                          break Fail268;
                        if(arg746.getSubterm(0) != m_71 && !m_71.match(arg746.getSubterm(0)))
                          break Fail268;
                        IStrategoTerm arg747 = arg746.getSubterm(1);
                        if(arg747.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg747).getConstructor())
                          break Fail268;
                        if(arg747.getSubterm(0) != n_71 && !n_71.match(arg747.getSubterm(0)))
                          break Fail268;
                        term = termFactory.makeAppl(Simplify._consEqu_2, new IStrategoTerm[]{m_71, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{n_71})});
                        if(true)
                          break Success212;
                      }
                      term = term416;
                    }
                    Success213:
                    { 
                      if(cons37 == Simplify._consAnd_2)
                      { 
                        Fail269:
                        { 
                          IStrategoTerm h_71 = null;
                          IStrategoTerm i_71 = null;
                          IStrategoTerm j_71 = null;
                          IStrategoTerm arg748 = term.getSubterm(0);
                          if(arg748.getTermType() != IStrategoTerm.APPL || Simplify._consGeq_2 != ((IStrategoAppl)arg748).getConstructor())
                            break Fail269;
                          h_71 = arg748.getSubterm(0);
                          IStrategoTerm arg749 = arg748.getSubterm(1);
                          if(arg749.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg749).getConstructor())
                            break Fail269;
                          i_71 = arg749.getSubterm(0);
                          IStrategoTerm arg750 = term.getSubterm(1);
                          if(arg750.getTermType() != IStrategoTerm.APPL || Simplify._consGeq_2 != ((IStrategoAppl)arg750).getConstructor())
                            break Fail269;
                          if(arg750.getSubterm(0) != h_71 && !h_71.match(arg750.getSubterm(0)))
                            break Fail269;
                          IStrategoTerm arg751 = arg750.getSubterm(1);
                          if(arg751.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg751).getConstructor())
                            break Fail269;
                          j_71 = arg751.getSubterm(0);
                          term = termFactory.makeTuple(i_71, j_71);
                          term = maxstring_0_0.instance.invoke(context, term);
                          if(term == null)
                            break Fail269;
                          term = termFactory.makeAppl(Simplify._consGeq_2, new IStrategoTerm[]{h_71, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{term})});
                          if(true)
                            break Success213;
                        }
                        term = term416;
                      }
                      Success214:
                      { 
                        if(cons37 == Simplify._consAnd_2)
                        { 
                          Fail270:
                          { 
                            IStrategoTerm b_71 = null;
                            IStrategoTerm c_71 = null;
                            IStrategoTerm f_71 = null;
                            IStrategoTerm arg752 = term.getSubterm(0);
                            if(arg752.getTermType() != IStrategoTerm.APPL || Simplify._consGeq_2 != ((IStrategoAppl)arg752).getConstructor())
                              break Fail270;
                            b_71 = arg752.getSubterm(0);
                            IStrategoTerm arg753 = arg752.getSubterm(1);
                            if(arg753.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg753).getConstructor())
                              break Fail270;
                            c_71 = arg753.getSubterm(0);
                            IStrategoTerm arg754 = term.getSubterm(1);
                            if(arg754.getTermType() != IStrategoTerm.APPL || Simplify._consGt_2 != ((IStrategoAppl)arg754).getConstructor())
                              break Fail270;
                            if(arg754.getSubterm(0) != b_71 && !b_71.match(arg754.getSubterm(0)))
                              break Fail270;
                            IStrategoTerm arg755 = arg754.getSubterm(1);
                            if(arg755.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg755).getConstructor())
                              break Fail270;
                            f_71 = arg755.getSubterm(0);
                            term = termFactory.makeTuple(c_71, f_71);
                            term = gt$S_0_0.instance.invoke(context, term);
                            if(term == null)
                              break Fail270;
                            term = termFactory.makeAppl(Simplify._consGeq_2, new IStrategoTerm[]{b_71, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{c_71})});
                            if(true)
                              break Success214;
                          }
                          term = term416;
                        }
                        Success215:
                        { 
                          if(cons37 == Simplify._consAnd_2)
                          { 
                            Fail271:
                            { 
                              IStrategoTerm x_70 = null;
                              IStrategoTerm y_70 = null;
                              IStrategoTerm z_70 = null;
                              IStrategoTerm arg756 = term.getSubterm(0);
                              if(arg756.getTermType() != IStrategoTerm.APPL || Simplify._consGeq_2 != ((IStrategoAppl)arg756).getConstructor())
                                break Fail271;
                              x_70 = arg756.getSubterm(0);
                              IStrategoTerm arg757 = arg756.getSubterm(1);
                              if(arg757.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg757).getConstructor())
                                break Fail271;
                              y_70 = arg757.getSubterm(0);
                              IStrategoTerm arg758 = term.getSubterm(1);
                              if(arg758.getTermType() != IStrategoTerm.APPL || Simplify._consGt_2 != ((IStrategoAppl)arg758).getConstructor())
                                break Fail271;
                              if(arg758.getSubterm(0) != x_70 && !x_70.match(arg758.getSubterm(0)))
                                break Fail271;
                              IStrategoTerm arg759 = arg758.getSubterm(1);
                              if(arg759.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg759).getConstructor())
                                break Fail271;
                              z_70 = arg759.getSubterm(0);
                              term = termFactory.makeTuple(y_70, z_70);
                              term = leq$S_0_0.instance.invoke(context, term);
                              if(term == null)
                                break Fail271;
                              term = termFactory.makeAppl(Simplify._consGt_2, new IStrategoTerm[]{x_70, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{z_70})});
                              if(true)
                                break Success215;
                            }
                            term = term416;
                          }
                          Success216:
                          { 
                            if(cons37 == Simplify._consAnd_2)
                            { 
                              Fail272:
                              { 
                                IStrategoTerm p_70 = null;
                                IStrategoTerm q_70 = null;
                                IStrategoTerm r_70 = null;
                                IStrategoTerm arg760 = term.getSubterm(0);
                                if(arg760.getTermType() != IStrategoTerm.APPL || Simplify._consGt_2 != ((IStrategoAppl)arg760).getConstructor())
                                  break Fail272;
                                p_70 = arg760.getSubterm(0);
                                IStrategoTerm arg761 = arg760.getSubterm(1);
                                if(arg761.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg761).getConstructor())
                                  break Fail272;
                                q_70 = arg761.getSubterm(0);
                                IStrategoTerm arg762 = term.getSubterm(1);
                                if(arg762.getTermType() != IStrategoTerm.APPL || Simplify._consGt_2 != ((IStrategoAppl)arg762).getConstructor())
                                  break Fail272;
                                if(arg762.getSubterm(0) != p_70 && !p_70.match(arg762.getSubterm(0)))
                                  break Fail272;
                                IStrategoTerm arg763 = arg762.getSubterm(1);
                                if(arg763.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg763).getConstructor())
                                  break Fail272;
                                r_70 = arg763.getSubterm(0);
                                term = termFactory.makeTuple(q_70, r_70);
                                term = maxstring_0_0.instance.invoke(context, term);
                                if(term == null)
                                  break Fail272;
                                term = termFactory.makeAppl(Simplify._consGt_2, new IStrategoTerm[]{p_70, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{term})});
                                if(true)
                                  break Success216;
                              }
                              term = term416;
                            }
                            Success217:
                            { 
                              if(cons37 == Simplify._consAnd_2)
                              { 
                                Fail273:
                                { 
                                  IStrategoTerm e_70 = null;
                                  IStrategoTerm f_70 = null;
                                  IStrategoTerm g_70 = null;
                                  IStrategoTerm h_70 = null;
                                  IStrategoTerm arg764 = term.getSubterm(0);
                                  if(arg764.getTermType() != IStrategoTerm.APPL || Simplify._consAnd_2 != ((IStrategoAppl)arg764).getConstructor())
                                    break Fail273;
                                  e_70 = arg764.getSubterm(0);
                                  IStrategoTerm arg765 = arg764.getSubterm(1);
                                  if(arg765.getTermType() != IStrategoTerm.APPL || Simplify._consLt_2 != ((IStrategoAppl)arg765).getConstructor())
                                    break Fail273;
                                  f_70 = arg765.getSubterm(0);
                                  IStrategoTerm arg766 = arg765.getSubterm(1);
                                  if(arg766.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg766).getConstructor())
                                    break Fail273;
                                  g_70 = arg766.getSubterm(0);
                                  IStrategoTerm arg767 = term.getSubterm(1);
                                  if(arg767.getTermType() != IStrategoTerm.APPL || Simplify._consLt_2 != ((IStrategoAppl)arg767).getConstructor())
                                    break Fail273;
                                  if(arg767.getSubterm(0) != f_70 && !f_70.match(arg767.getSubterm(0)))
                                    break Fail273;
                                  IStrategoTerm arg768 = arg767.getSubterm(1);
                                  if(arg768.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg768).getConstructor())
                                    break Fail273;
                                  h_70 = arg768.getSubterm(0);
                                  term = termFactory.makeTuple(g_70, h_70);
                                  term = minstring_0_0.instance.invoke(context, term);
                                  if(term == null)
                                    break Fail273;
                                  term = termFactory.makeAppl(Simplify._consAnd_2, new IStrategoTerm[]{e_70, termFactory.makeAppl(Simplify._consLt_2, new IStrategoTerm[]{f_70, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{term})})});
                                  if(true)
                                    break Success217;
                                }
                                term = term416;
                              }
                              Success218:
                              { 
                                if(cons37 == Simplify._consAnd_2)
                                { 
                                  Fail274:
                                  { 
                                    IStrategoTerm x_69 = null;
                                    IStrategoTerm a_70 = null;
                                    IStrategoTerm b_70 = null;
                                    IStrategoTerm c_70 = null;
                                    IStrategoTerm arg769 = term.getSubterm(0);
                                    if(arg769.getTermType() != IStrategoTerm.APPL || Simplify._consAnd_2 != ((IStrategoAppl)arg769).getConstructor())
                                      break Fail274;
                                    x_69 = arg769.getSubterm(0);
                                    IStrategoTerm arg770 = arg769.getSubterm(1);
                                    if(arg770.getTermType() != IStrategoTerm.APPL || Simplify._consLt_2 != ((IStrategoAppl)arg770).getConstructor())
                                      break Fail274;
                                    a_70 = arg770.getSubterm(0);
                                    IStrategoTerm arg771 = arg770.getSubterm(1);
                                    if(arg771.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg771).getConstructor())
                                      break Fail274;
                                    b_70 = arg771.getSubterm(0);
                                    IStrategoTerm arg772 = term.getSubterm(1);
                                    if(arg772.getTermType() != IStrategoTerm.APPL || Simplify._consLeq_2 != ((IStrategoAppl)arg772).getConstructor())
                                      break Fail274;
                                    if(arg772.getSubterm(0) != a_70 && !a_70.match(arg772.getSubterm(0)))
                                      break Fail274;
                                    IStrategoTerm arg773 = arg772.getSubterm(1);
                                    if(arg773.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg773).getConstructor())
                                      break Fail274;
                                    c_70 = arg773.getSubterm(0);
                                    term = termFactory.makeTuple(b_70, c_70);
                                    term = gt$S_0_0.instance.invoke(context, term);
                                    if(term == null)
                                      break Fail274;
                                    term = termFactory.makeAppl(Simplify._consAnd_2, new IStrategoTerm[]{x_69, termFactory.makeAppl(Simplify._consLeq_2, new IStrategoTerm[]{a_70, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{c_70})})});
                                    if(true)
                                      break Success218;
                                  }
                                  term = term416;
                                }
                                term = $Merge$Compare_0_0_fragment_0.instance.invoke(context, term);
                                if(term == null)
                                  break Fail261;
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class $Eval$Expr_0_0 extends Strategy 
  { 
    public static $Eval$Expr_0_0 instance = new $Eval$Expr_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      ITermFactory termFactory = context.getFactory();
      context.push("EvalExpr_0_0");
      Fail275:
      { 
        IStrategoTerm term429 = term;
        IStrategoConstructor cons38 = term.getTermType() == IStrategoTerm.APPL ? ((IStrategoAppl)term).getConstructor() : null;
        Success219:
        { 
          if(cons38 == Simplify._consAdd_2)
          { 
            Fail276:
            { 
              IStrategoTerm l_76 = null;
              IStrategoTerm n_76 = null;
              IStrategoTerm arg774 = term.getSubterm(0);
              if(arg774.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg774).getConstructor())
                break Fail276;
              l_76 = arg774.getSubterm(0);
              IStrategoTerm arg775 = term.getSubterm(1);
              if(arg775.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg775).getConstructor())
                break Fail276;
              n_76 = arg775.getSubterm(0);
              term = termFactory.makeTuple(l_76, n_76);
              term = add$S_0_0.instance.invoke(context, term);
              if(term == null)
                break Fail276;
              term = termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{term});
              if(true)
                break Success219;
            }
            term = term429;
          }
          Success220:
          { 
            if(cons38 == Simplify._consAdd_2)
            { 
              Fail277:
              { 
                IStrategoTerm d_76 = null;
                IStrategoTerm f_76 = null;
                IStrategoTerm h_76 = null;
                IStrategoTerm arg776 = term.getSubterm(0);
                if(arg776.getTermType() != IStrategoTerm.APPL || Simplify._consAdd_2 != ((IStrategoAppl)arg776).getConstructor())
                  break Fail277;
                d_76 = arg776.getSubterm(0);
                IStrategoTerm arg777 = arg776.getSubterm(1);
                if(arg777.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg777).getConstructor())
                  break Fail277;
                f_76 = arg777.getSubterm(0);
                IStrategoTerm arg778 = term.getSubterm(1);
                if(arg778.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg778).getConstructor())
                  break Fail277;
                h_76 = arg778.getSubterm(0);
                term = termFactory.makeTuple(f_76, h_76);
                term = add$S_0_0.instance.invoke(context, term);
                if(term == null)
                  break Fail277;
                term = termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{d_76, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{term})});
                if(true)
                  break Success220;
              }
              term = term429;
            }
            Success221:
            { 
              if(cons38 == Simplify._consMul_2)
              { 
                Fail278:
                { 
                  IStrategoTerm z_75 = null;
                  IStrategoTerm a_76 = null;
                  IStrategoTerm arg779 = term.getSubterm(0);
                  if(arg779.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg779).getConstructor())
                    break Fail278;
                  z_75 = arg779.getSubterm(0);
                  IStrategoTerm arg780 = term.getSubterm(1);
                  if(arg780.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg780).getConstructor())
                    break Fail278;
                  a_76 = arg780.getSubterm(0);
                  term = termFactory.makeTuple(z_75, a_76);
                  term = mul$S_0_0.instance.invoke(context, term);
                  if(term == null)
                    break Fail278;
                  term = termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{term});
                  if(true)
                    break Success221;
                }
                term = term429;
              }
              Success222:
              { 
                if(cons38 == Simplify._consMul_2)
                { 
                  Fail279:
                  { 
                    IStrategoTerm u_75 = null;
                    IStrategoTerm v_75 = null;
                    IStrategoTerm w_75 = null;
                    IStrategoTerm arg781 = term.getSubterm(0);
                    if(arg781.getTermType() != IStrategoTerm.APPL || Simplify._consMul_2 != ((IStrategoAppl)arg781).getConstructor())
                      break Fail279;
                    u_75 = arg781.getSubterm(0);
                    IStrategoTerm arg782 = arg781.getSubterm(1);
                    if(arg782.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg782).getConstructor())
                      break Fail279;
                    v_75 = arg782.getSubterm(0);
                    IStrategoTerm arg783 = term.getSubterm(1);
                    if(arg783.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg783).getConstructor())
                      break Fail279;
                    w_75 = arg783.getSubterm(0);
                    term = termFactory.makeTuple(v_75, w_75);
                    term = mul$S_0_0.instance.invoke(context, term);
                    if(term == null)
                      break Fail279;
                    term = termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{u_75, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{term})});
                    if(true)
                      break Success222;
                  }
                  term = term429;
                }
                Success223:
                { 
                  if(cons38 == Simplify._consMul_2)
                  { 
                    Fail280:
                    { 
                      IStrategoTerm s_75 = null;
                      IStrategoTerm t_75 = null;
                      IStrategoTerm arg784 = term.getSubterm(0);
                      if(arg784.getTermType() != IStrategoTerm.APPL || Simplify._consDiv_2 != ((IStrategoAppl)arg784).getConstructor())
                        break Fail280;
                      s_75 = arg784.getSubterm(0);
                      t_75 = arg784.getSubterm(1);
                      IStrategoTerm arg785 = term.getSubterm(1);
                      if(arg785.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg785).getConstructor())
                        break Fail280;
                      IStrategoTerm arg786 = arg785.getSubterm(0);
                      if(arg786.getTermType() != IStrategoTerm.STRING || !"-1".equals(((IStrategoString)arg786).stringValue()))
                        break Fail280;
                      term = termFactory.makeAppl(Simplify._consDiv_2, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{s_75, Simplify.constInt2}), t_75});
                      if(true)
                        break Success223;
                    }
                    term = term429;
                  }
                  Success224:
                  { 
                    if(cons38 == Simplify._consDiv_2)
                    { 
                      Fail281:
                      { 
                        IStrategoTerm o_75 = null;
                        IStrategoTerm p_75 = null;
                        IStrategoTerm arg787 = term.getSubterm(0);
                        if(arg787.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg787).getConstructor())
                          break Fail281;
                        o_75 = arg787.getSubterm(0);
                        IStrategoTerm arg788 = term.getSubterm(1);
                        if(arg788.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg788).getConstructor())
                          break Fail281;
                        p_75 = arg788.getSubterm(0);
                        term = termFactory.makeTuple(o_75, p_75);
                        term = mod$S_0_0.instance.invoke(context, term);
                        if(term == null)
                          break Fail281;
                        if(term.getTermType() != IStrategoTerm.STRING || !"0".equals(((IStrategoString)term).stringValue()))
                          break Fail281;
                        term = termFactory.makeTuple(o_75, p_75);
                        term = div$S_0_0.instance.invoke(context, term);
                        if(term == null)
                          break Fail281;
                        term = termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{term});
                        if(true)
                          break Success224;
                      }
                      term = term429;
                    }
                    Success225:
                    { 
                      if(cons38 == Simplify._consDiv_2)
                      { 
                        Fail282:
                        { 
                          IStrategoTerm j_75 = null;
                          IStrategoTerm k_75 = null;
                          IStrategoTerm l_75 = null;
                          IStrategoTerm arg789 = term.getSubterm(0);
                          if(arg789.getTermType() != IStrategoTerm.APPL || Simplify._consMul_2 != ((IStrategoAppl)arg789).getConstructor())
                            break Fail282;
                          j_75 = arg789.getSubterm(0);
                          IStrategoTerm arg790 = arg789.getSubterm(1);
                          if(arg790.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg790).getConstructor())
                            break Fail282;
                          k_75 = arg790.getSubterm(0);
                          IStrategoTerm arg791 = term.getSubterm(1);
                          if(arg791.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg791).getConstructor())
                            break Fail282;
                          l_75 = arg791.getSubterm(0);
                          term = termFactory.makeTuple(k_75, l_75);
                          term = mod$S_0_0.instance.invoke(context, term);
                          if(term == null)
                            break Fail282;
                          if(term.getTermType() != IStrategoTerm.STRING || !"0".equals(((IStrategoString)term).stringValue()))
                            break Fail282;
                          term = termFactory.makeTuple(k_75, l_75);
                          term = div$S_0_0.instance.invoke(context, term);
                          if(term == null)
                            break Fail282;
                          term = termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{j_75, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{term})});
                          if(true)
                            break Success225;
                        }
                        term = term429;
                      }
                      Success226:
                      { 
                        if(cons38 == Simplify._consMul_2)
                        { 
                          Fail283:
                          { 
                            IStrategoTerm e_75 = null;
                            IStrategoTerm f_75 = null;
                            IStrategoTerm g_75 = null;
                            IStrategoTerm arg792 = term.getSubterm(0);
                            if(arg792.getTermType() != IStrategoTerm.APPL || Simplify._consAdd_2 != ((IStrategoAppl)arg792).getConstructor())
                              break Fail283;
                            e_75 = arg792.getSubterm(0);
                            IStrategoTerm arg793 = arg792.getSubterm(1);
                            if(arg793.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg793).getConstructor())
                              break Fail283;
                            f_75 = arg793.getSubterm(0);
                            IStrategoTerm arg794 = term.getSubterm(1);
                            if(arg794.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg794).getConstructor())
                              break Fail283;
                            g_75 = arg794.getSubterm(0);
                            term = termFactory.makeTuple(f_75, g_75);
                            term = mul$S_0_0.instance.invoke(context, term);
                            if(term == null)
                              break Fail283;
                            term = termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{e_75, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{g_75})}), termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{term})});
                            if(true)
                              break Success226;
                          }
                          term = term429;
                        }
                        Success227:
                        { 
                          if(cons38 == Simplify._consAdd_2)
                          { 
                            Fail284:
                            { 
                              IStrategoTerm z_74 = null;
                              IStrategoTerm a_75 = null;
                              IStrategoTerm b_75 = null;
                              IStrategoTerm arg795 = term.getSubterm(0);
                              if(arg795.getTermType() != IStrategoTerm.APPL || Simplify._consMul_2 != ((IStrategoAppl)arg795).getConstructor())
                                break Fail284;
                              z_74 = arg795.getSubterm(0);
                              IStrategoTerm arg796 = arg795.getSubterm(1);
                              if(arg796.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg796).getConstructor())
                                break Fail284;
                              a_75 = arg796.getSubterm(0);
                              IStrategoTerm arg797 = term.getSubterm(1);
                              if(arg797.getTermType() != IStrategoTerm.APPL || Simplify._consMul_2 != ((IStrategoAppl)arg797).getConstructor())
                                break Fail284;
                              if(arg797.getSubterm(0) != z_74 && !z_74.match(arg797.getSubterm(0)))
                                break Fail284;
                              IStrategoTerm arg798 = arg797.getSubterm(1);
                              if(arg798.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg798).getConstructor())
                                break Fail284;
                              b_75 = arg798.getSubterm(0);
                              term = termFactory.makeTuple(a_75, b_75);
                              term = add$S_0_0.instance.invoke(context, term);
                              if(term == null)
                                break Fail284;
                              term = termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{z_74, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{term})});
                              if(true)
                                break Success227;
                            }
                            term = term429;
                          }
                          Success228:
                          { 
                            if(cons38 == Simplify._consAdd_2)
                            { 
                              Fail285:
                              { 
                                IStrategoTerm t_74 = null;
                                IStrategoTerm u_74 = null;
                                IStrategoTerm v_74 = null;
                                IStrategoTerm w_74 = null;
                                IStrategoTerm arg799 = term.getSubterm(0);
                                if(arg799.getTermType() != IStrategoTerm.APPL || Simplify._consAdd_2 != ((IStrategoAppl)arg799).getConstructor())
                                  break Fail285;
                                t_74 = arg799.getSubterm(0);
                                IStrategoTerm arg800 = arg799.getSubterm(1);
                                if(arg800.getTermType() != IStrategoTerm.APPL || Simplify._consMul_2 != ((IStrategoAppl)arg800).getConstructor())
                                  break Fail285;
                                u_74 = arg800.getSubterm(0);
                                IStrategoTerm arg801 = arg800.getSubterm(1);
                                if(arg801.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg801).getConstructor())
                                  break Fail285;
                                v_74 = arg801.getSubterm(0);
                                IStrategoTerm arg802 = term.getSubterm(1);
                                if(arg802.getTermType() != IStrategoTerm.APPL || Simplify._consMul_2 != ((IStrategoAppl)arg802).getConstructor())
                                  break Fail285;
                                if(arg802.getSubterm(0) != u_74 && !u_74.match(arg802.getSubterm(0)))
                                  break Fail285;
                                IStrategoTerm arg803 = arg802.getSubterm(1);
                                if(arg803.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg803).getConstructor())
                                  break Fail285;
                                w_74 = arg803.getSubterm(0);
                                term = termFactory.makeTuple(v_74, w_74);
                                term = add$S_0_0.instance.invoke(context, term);
                                if(term == null)
                                  break Fail285;
                                term = termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{t_74, termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{u_74, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{term})})});
                                if(true)
                                  break Success228;
                              }
                              term = term429;
                            }
                            Success229:
                            { 
                              if(cons38 == Simplify._consDiv_2)
                              { 
                                Fail286:
                                { 
                                  IStrategoTerm s_74 = null;
                                  s_74 = term.getSubterm(0);
                                  if(term.getSubterm(1) != s_74 && !s_74.match(term.getSubterm(1)))
                                    break Fail286;
                                  term = Simplify.constInt0;
                                  if(true)
                                    break Success229;
                                }
                                term = term429;
                              }
                              Success230:
                              { 
                                if(cons38 == Simplify._consDiv_2)
                                { 
                                  Fail287:
                                  { 
                                    IStrategoTerm q_74 = null;
                                    IStrategoTerm r_74 = null;
                                    IStrategoTerm arg804 = term.getSubterm(0);
                                    if(arg804.getTermType() != IStrategoTerm.APPL || Simplify._consMul_2 != ((IStrategoAppl)arg804).getConstructor())
                                      break Fail287;
                                    q_74 = arg804.getSubterm(0);
                                    IStrategoTerm arg805 = arg804.getSubterm(1);
                                    if(arg805.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg805).getConstructor())
                                      break Fail287;
                                    r_74 = arg805.getSubterm(0);
                                    if(term.getSubterm(1) != q_74 && !q_74.match(term.getSubterm(1)))
                                      break Fail287;
                                    term = termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{r_74});
                                    if(true)
                                      break Success230;
                                  }
                                  term = term429;
                                }
                                Success231:
                                { 
                                  if(cons38 == Simplify._consDiv_2)
                                  { 
                                    Fail288:
                                    { 
                                      IStrategoTerm o_74 = null;
                                      IStrategoTerm p_74 = null;
                                      o_74 = term.getSubterm(0);
                                      IStrategoTerm arg806 = term.getSubterm(1);
                                      if(arg806.getTermType() != IStrategoTerm.APPL || Simplify._consMul_2 != ((IStrategoAppl)arg806).getConstructor())
                                        break Fail288;
                                      if(arg806.getSubterm(0) != o_74 && !o_74.match(arg806.getSubterm(0)))
                                        break Fail288;
                                      IStrategoTerm arg807 = arg806.getSubterm(1);
                                      if(arg807.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg807).getConstructor())
                                        break Fail288;
                                      p_74 = arg807.getSubterm(0);
                                      term = termFactory.makeAppl(Simplify._consDiv_2, new IStrategoTerm[]{Simplify.constInt0, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{p_74})});
                                      if(true)
                                        break Success231;
                                    }
                                    term = term429;
                                  }
                                  Success232:
                                  { 
                                    if(cons38 == Simplify._consDiv_2)
                                    { 
                                      Fail289:
                                      { 
                                        IStrategoTerm l_74 = null;
                                        IStrategoTerm m_74 = null;
                                        IStrategoTerm n_74 = null;
                                        IStrategoTerm arg808 = term.getSubterm(0);
                                        if(arg808.getTermType() != IStrategoTerm.APPL || Simplify._consMul_2 != ((IStrategoAppl)arg808).getConstructor())
                                          break Fail289;
                                        l_74 = arg808.getSubterm(0);
                                        IStrategoTerm arg809 = arg808.getSubterm(1);
                                        if(arg809.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg809).getConstructor())
                                          break Fail289;
                                        m_74 = arg809.getSubterm(0);
                                        IStrategoTerm arg810 = term.getSubterm(1);
                                        if(arg810.getTermType() != IStrategoTerm.APPL || Simplify._consMul_2 != ((IStrategoAppl)arg810).getConstructor())
                                          break Fail289;
                                        if(arg810.getSubterm(0) != l_74 && !l_74.match(arg810.getSubterm(0)))
                                          break Fail289;
                                        IStrategoTerm arg811 = arg810.getSubterm(1);
                                        if(arg811.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg811).getConstructor())
                                          break Fail289;
                                        n_74 = arg811.getSubterm(0);
                                        term = termFactory.makeAppl(Simplify._consDiv_2, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{m_74}), termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{n_74})});
                                        if(true)
                                          break Success232;
                                      }
                                      term = term429;
                                    }
                                    Success233:
                                    { 
                                      if(cons38 == Simplify._consDiv_2)
                                      { 
                                        Fail290:
                                        { 
                                          IStrategoTerm f_74 = null;
                                          IStrategoTerm g_74 = null;
                                          IStrategoTerm arg812 = term.getSubterm(0);
                                          if(arg812.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg812).getConstructor())
                                            break Fail290;
                                          f_74 = arg812.getSubterm(0);
                                          IStrategoTerm arg813 = term.getSubterm(1);
                                          if(arg813.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg813).getConstructor())
                                            break Fail290;
                                          g_74 = arg813.getSubterm(0);
                                          term = termFactory.makeTuple(f_74, g_74);
                                          term = div$S_0_0.instance.invoke(context, term);
                                          if(term == null)
                                            break Fail290;
                                          term = termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{term});
                                          if(true)
                                            break Success233;
                                        }
                                        term = term429;
                                      }
                                      Success234:
                                      { 
                                        if(cons38 == Simplify._consDiv_2)
                                        { 
                                          Fail291:
                                          { 
                                            IStrategoTerm y_73 = null;
                                            IStrategoTerm z_73 = null;
                                            IStrategoTerm a_74 = null;
                                            IStrategoTerm arg814 = term.getSubterm(0);
                                            if(arg814.getTermType() != IStrategoTerm.APPL || Simplify._consDiv_2 != ((IStrategoAppl)arg814).getConstructor())
                                              break Fail291;
                                            y_73 = arg814.getSubterm(0);
                                            IStrategoTerm arg815 = arg814.getSubterm(1);
                                            if(arg815.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg815).getConstructor())
                                              break Fail291;
                                            z_73 = arg815.getSubterm(0);
                                            IStrategoTerm arg816 = term.getSubterm(1);
                                            if(arg816.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg816).getConstructor())
                                              break Fail291;
                                            a_74 = arg816.getSubterm(0);
                                            term = termFactory.makeTuple(z_73, a_74);
                                            term = mul$S_0_0.instance.invoke(context, term);
                                            if(term == null)
                                              break Fail291;
                                            term = termFactory.makeAppl(Simplify._consDiv_2, new IStrategoTerm[]{y_73, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{term})});
                                            if(true)
                                              break Success234;
                                          }
                                          term = term429;
                                        }
                                        Success235:
                                        { 
                                          if(cons38 == Simplify._consMod_2)
                                          { 
                                            Fail292:
                                            { 
                                              IStrategoTerm t_73 = null;
                                              IStrategoTerm v_73 = null;
                                              IStrategoTerm arg817 = term.getSubterm(0);
                                              if(arg817.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg817).getConstructor())
                                                break Fail292;
                                              t_73 = arg817.getSubterm(0);
                                              IStrategoTerm arg818 = term.getSubterm(1);
                                              if(arg818.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg818).getConstructor())
                                                break Fail292;
                                              v_73 = arg818.getSubterm(0);
                                              term = termFactory.makeTuple(t_73, v_73);
                                              term = mod$S_0_0.instance.invoke(context, term);
                                              if(term == null)
                                                break Fail292;
                                              term = termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{term});
                                              if(true)
                                                break Success235;
                                            }
                                            term = term429;
                                          }
                                          Success236:
                                          { 
                                            if(cons38 == Simplify._consLt_2)
                                            { 
                                              Fail293:
                                              { 
                                                IStrategoTerm r_73 = null;
                                                IStrategoTerm s_73 = null;
                                                IStrategoTerm arg819 = term.getSubterm(0);
                                                if(arg819.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg819).getConstructor())
                                                  break Fail293;
                                                r_73 = arg819.getSubterm(0);
                                                IStrategoTerm arg820 = term.getSubterm(1);
                                                if(arg820.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg820).getConstructor())
                                                  break Fail293;
                                                s_73 = arg820.getSubterm(0);
                                                term = termFactory.makeTuple(r_73, s_73);
                                                term = compare_1_0.instance.invoke(context, term, lt$S_0_0.instance);
                                                if(term == null)
                                                  break Fail293;
                                                if(true)
                                                  break Success236;
                                              }
                                              term = term429;
                                            }
                                            Success237:
                                            { 
                                              if(cons38 == Simplify._consGt_2)
                                              { 
                                                Fail294:
                                                { 
                                                  IStrategoTerm p_73 = null;
                                                  IStrategoTerm q_73 = null;
                                                  IStrategoTerm arg821 = term.getSubterm(0);
                                                  if(arg821.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg821).getConstructor())
                                                    break Fail294;
                                                  p_73 = arg821.getSubterm(0);
                                                  IStrategoTerm arg822 = term.getSubterm(1);
                                                  if(arg822.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg822).getConstructor())
                                                    break Fail294;
                                                  q_73 = arg822.getSubterm(0);
                                                  term = termFactory.makeTuple(p_73, q_73);
                                                  term = compare_1_0.instance.invoke(context, term, gt$S_0_0.instance);
                                                  if(term == null)
                                                    break Fail294;
                                                  if(true)
                                                    break Success237;
                                                }
                                                term = term429;
                                              }
                                              Success238:
                                              { 
                                                if(cons38 == Simplify._consLeq_2)
                                                { 
                                                  Fail295:
                                                  { 
                                                    IStrategoTerm m_73 = null;
                                                    IStrategoTerm o_73 = null;
                                                    IStrategoTerm arg823 = term.getSubterm(0);
                                                    if(arg823.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg823).getConstructor())
                                                      break Fail295;
                                                    m_73 = arg823.getSubterm(0);
                                                    IStrategoTerm arg824 = term.getSubterm(1);
                                                    if(arg824.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg824).getConstructor())
                                                      break Fail295;
                                                    o_73 = arg824.getSubterm(0);
                                                    term = termFactory.makeTuple(m_73, o_73);
                                                    term = compare_1_0.instance.invoke(context, term, leq$S_0_0.instance);
                                                    if(term == null)
                                                      break Fail295;
                                                    if(true)
                                                      break Success238;
                                                  }
                                                  term = term429;
                                                }
                                                Success239:
                                                { 
                                                  if(cons38 == Simplify._consGeq_2)
                                                  { 
                                                    Fail296:
                                                    { 
                                                      IStrategoTerm k_73 = null;
                                                      IStrategoTerm l_73 = null;
                                                      IStrategoTerm arg825 = term.getSubterm(0);
                                                      if(arg825.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg825).getConstructor())
                                                        break Fail296;
                                                      k_73 = arg825.getSubterm(0);
                                                      IStrategoTerm arg826 = term.getSubterm(1);
                                                      if(arg826.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg826).getConstructor())
                                                        break Fail296;
                                                      l_73 = arg826.getSubterm(0);
                                                      term = termFactory.makeTuple(k_73, l_73);
                                                      term = compare_1_0.instance.invoke(context, term, geq$S_0_0.instance);
                                                      if(term == null)
                                                        break Fail296;
                                                      if(true)
                                                        break Success239;
                                                    }
                                                    term = term429;
                                                  }
                                                  Success240:
                                                  { 
                                                    if(cons38 == Simplify._consEqu_2)
                                                    { 
                                                      Fail297:
                                                      { 
                                                        IStrategoTerm i_73 = null;
                                                        IStrategoTerm j_73 = null;
                                                        IStrategoTerm arg827 = term.getSubterm(0);
                                                        if(arg827.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg827).getConstructor())
                                                          break Fail297;
                                                        i_73 = arg827.getSubterm(0);
                                                        IStrategoTerm arg828 = term.getSubterm(1);
                                                        if(arg828.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg828).getConstructor())
                                                          break Fail297;
                                                        j_73 = arg828.getSubterm(0);
                                                        term = termFactory.makeTuple(i_73, j_73);
                                                        term = compare_1_0.instance.invoke(context, term, eq_0_0.instance);
                                                        if(term == null)
                                                          break Fail297;
                                                        if(true)
                                                          break Success240;
                                                      }
                                                      term = term429;
                                                    }
                                                    Success241:
                                                    { 
                                                      if(cons38 == Simplify._consNeq_2)
                                                      { 
                                                        Fail298:
                                                        { 
                                                          IStrategoTerm f_73 = null;
                                                          IStrategoTerm h_73 = null;
                                                          IStrategoTerm arg829 = term.getSubterm(0);
                                                          if(arg829.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg829).getConstructor())
                                                            break Fail298;
                                                          f_73 = arg829.getSubterm(0);
                                                          IStrategoTerm arg830 = term.getSubterm(1);
                                                          if(arg830.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg830).getConstructor())
                                                            break Fail298;
                                                          h_73 = arg830.getSubterm(0);
                                                          term = termFactory.makeTuple(f_73, h_73);
                                                          term = compare_1_0.instance.invoke(context, term, lifted148.instance);
                                                          if(term == null)
                                                            break Fail298;
                                                          if(true)
                                                            break Success241;
                                                        }
                                                        term = term429;
                                                      }
                                                      Success242:
                                                      { 
                                                        if(cons38 == Simplify._consDiv_2)
                                                        { 
                                                          Fail299:
                                                          { 
                                                            IStrategoTerm e_73 = null;
                                                            e_73 = term.getSubterm(0);
                                                            IStrategoTerm arg831 = term.getSubterm(1);
                                                            if(arg831.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg831).getConstructor())
                                                              break Fail299;
                                                            IStrategoTerm arg832 = arg831.getSubterm(0);
                                                            if(arg832.getTermType() != IStrategoTerm.STRING || !"1".equals(((IStrategoString)arg832).stringValue()))
                                                              break Fail299;
                                                            term = e_73;
                                                            if(true)
                                                              break Success242;
                                                          }
                                                          term = term429;
                                                        }
                                                        Success243:
                                                        { 
                                                          if(cons38 == Simplify._consMul_2)
                                                          { 
                                                            Fail300:
                                                            { 
                                                              IStrategoTerm arg833 = term.getSubterm(1);
                                                              if(arg833.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg833).getConstructor())
                                                                break Fail300;
                                                              IStrategoTerm arg834 = arg833.getSubterm(0);
                                                              if(arg834.getTermType() != IStrategoTerm.STRING || !"0".equals(((IStrategoString)arg834).stringValue()))
                                                                break Fail300;
                                                              term = Simplify.constInt3;
                                                              if(true)
                                                                break Success243;
                                                            }
                                                            term = term429;
                                                          }
                                                          Success244:
                                                          { 
                                                            if(cons38 == Simplify._consMul_2)
                                                            { 
                                                              Fail301:
                                                              { 
                                                                IStrategoTerm arg835 = term.getSubterm(0);
                                                                if(arg835.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg835).getConstructor())
                                                                  break Fail301;
                                                                IStrategoTerm arg836 = arg835.getSubterm(0);
                                                                if(arg836.getTermType() != IStrategoTerm.STRING || !"0".equals(((IStrategoString)arg836).stringValue()))
                                                                  break Fail301;
                                                                term = Simplify.constInt3;
                                                                if(true)
                                                                  break Success244;
                                                              }
                                                              term = term429;
                                                            }
                                                            Success245:
                                                            { 
                                                              if(cons38 == Simplify._consDiv_2)
                                                              { 
                                                                Fail302:
                                                                { 
                                                                  IStrategoTerm arg837 = term.getSubterm(0);
                                                                  if(arg837.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg837).getConstructor())
                                                                    break Fail302;
                                                                  IStrategoTerm arg838 = arg837.getSubterm(0);
                                                                  if(arg838.getTermType() != IStrategoTerm.STRING || !"0".equals(((IStrategoString)arg838).stringValue()))
                                                                    break Fail302;
                                                                  term = Simplify.constInt3;
                                                                  if(true)
                                                                    break Success245;
                                                                }
                                                                term = term429;
                                                              }
                                                              Success246:
                                                              { 
                                                                if(cons38 == Simplify._consOr_2)
                                                                { 
                                                                  Fail303:
                                                                  { 
                                                                    IStrategoTerm arg839 = term.getSubterm(0);
                                                                    if(arg839.getTermType() != IStrategoTerm.APPL || Simplify._consTrue_0 != ((IStrategoAppl)arg839).getConstructor())
                                                                      break Fail303;
                                                                    term = Simplify.constTrue0;
                                                                    if(true)
                                                                      break Success246;
                                                                  }
                                                                  term = term429;
                                                                }
                                                                Success247:
                                                                { 
                                                                  if(cons38 == Simplify._consOr_2)
                                                                  { 
                                                                    Fail304:
                                                                    { 
                                                                      IStrategoTerm arg840 = term.getSubterm(1);
                                                                      if(arg840.getTermType() != IStrategoTerm.APPL || Simplify._consTrue_0 != ((IStrategoAppl)arg840).getConstructor())
                                                                        break Fail304;
                                                                      term = Simplify.constTrue0;
                                                                      if(true)
                                                                        break Success247;
                                                                    }
                                                                    term = term429;
                                                                  }
                                                                  Success248:
                                                                  { 
                                                                    if(cons38 == Simplify._consOr_2)
                                                                    { 
                                                                      Fail305:
                                                                      { 
                                                                        IStrategoTerm x_72 = null;
                                                                        x_72 = term.getSubterm(0);
                                                                        IStrategoTerm arg841 = term.getSubterm(1);
                                                                        if(arg841.getTermType() != IStrategoTerm.APPL || Simplify._consFalse_0 != ((IStrategoAppl)arg841).getConstructor())
                                                                          break Fail305;
                                                                        term = x_72;
                                                                        if(true)
                                                                          break Success248;
                                                                      }
                                                                      term = term429;
                                                                    }
                                                                    Success249:
                                                                    { 
                                                                      if(cons38 == Simplify._consOr_2)
                                                                      { 
                                                                        Fail306:
                                                                        { 
                                                                          IStrategoTerm w_72 = null;
                                                                          IStrategoTerm arg842 = term.getSubterm(0);
                                                                          if(arg842.getTermType() != IStrategoTerm.APPL || Simplify._consFalse_0 != ((IStrategoAppl)arg842).getConstructor())
                                                                            break Fail306;
                                                                          w_72 = term.getSubterm(1);
                                                                          term = w_72;
                                                                          if(true)
                                                                            break Success249;
                                                                        }
                                                                        term = term429;
                                                                      }
                                                                      Success250:
                                                                      { 
                                                                        if(cons38 == Simplify._consAnd_2)
                                                                        { 
                                                                          Fail307:
                                                                          { 
                                                                            IStrategoTerm v_72 = null;
                                                                            v_72 = term.getSubterm(0);
                                                                            IStrategoTerm arg843 = term.getSubterm(1);
                                                                            if(arg843.getTermType() != IStrategoTerm.APPL || Simplify._consTrue_0 != ((IStrategoAppl)arg843).getConstructor())
                                                                              break Fail307;
                                                                            term = v_72;
                                                                            if(true)
                                                                              break Success250;
                                                                          }
                                                                          term = term429;
                                                                        }
                                                                        Success251:
                                                                        { 
                                                                          if(cons38 == Simplify._consAnd_2)
                                                                          { 
                                                                            Fail308:
                                                                            { 
                                                                              IStrategoTerm u_72 = null;
                                                                              IStrategoTerm arg844 = term.getSubterm(0);
                                                                              if(arg844.getTermType() != IStrategoTerm.APPL || Simplify._consTrue_0 != ((IStrategoAppl)arg844).getConstructor())
                                                                                break Fail308;
                                                                              u_72 = term.getSubterm(1);
                                                                              term = u_72;
                                                                              if(true)
                                                                                break Success251;
                                                                            }
                                                                            term = term429;
                                                                          }
                                                                          Success252:
                                                                          { 
                                                                            if(cons38 == Simplify._consAnd_2)
                                                                            { 
                                                                              Fail309:
                                                                              { 
                                                                                IStrategoTerm arg845 = term.getSubterm(1);
                                                                                if(arg845.getTermType() != IStrategoTerm.APPL || Simplify._consFalse_0 != ((IStrategoAppl)arg845).getConstructor())
                                                                                  break Fail309;
                                                                                term = Simplify.constFalse0;
                                                                                if(true)
                                                                                  break Success252;
                                                                              }
                                                                              term = term429;
                                                                            }
                                                                            Success253:
                                                                            { 
                                                                              if(cons38 == Simplify._consAnd_2)
                                                                              { 
                                                                                Fail310:
                                                                                { 
                                                                                  IStrategoTerm arg846 = term.getSubterm(0);
                                                                                  if(arg846.getTermType() != IStrategoTerm.APPL || Simplify._consFalse_0 != ((IStrategoAppl)arg846).getConstructor())
                                                                                    break Fail310;
                                                                                  term = Simplify.constFalse0;
                                                                                  if(true)
                                                                                    break Success253;
                                                                                }
                                                                                term = term429;
                                                                              }
                                                                              Success254:
                                                                              { 
                                                                                if(cons38 == Simplify._consNot_1)
                                                                                { 
                                                                                  Fail311:
                                                                                  { 
                                                                                    IStrategoTerm arg847 = term.getSubterm(0);
                                                                                    if(arg847.getTermType() != IStrategoTerm.APPL || Simplify._consTrue_0 != ((IStrategoAppl)arg847).getConstructor())
                                                                                      break Fail311;
                                                                                    term = Simplify.constFalse0;
                                                                                    if(true)
                                                                                      break Success254;
                                                                                  }
                                                                                  term = term429;
                                                                                }
                                                                                Success255:
                                                                                { 
                                                                                  if(cons38 == Simplify._consNot_1)
                                                                                  { 
                                                                                    Fail312:
                                                                                    { 
                                                                                      IStrategoTerm arg848 = term.getSubterm(0);
                                                                                      if(arg848.getTermType() != IStrategoTerm.APPL || Simplify._consFalse_0 != ((IStrategoAppl)arg848).getConstructor())
                                                                                        break Fail312;
                                                                                      term = Simplify.constTrue0;
                                                                                      if(true)
                                                                                        break Success255;
                                                                                    }
                                                                                    term = term429;
                                                                                  }
                                                                                  Success256:
                                                                                  { 
                                                                                    if(cons38 == Simplify._consNot_1)
                                                                                    { 
                                                                                      Fail313:
                                                                                      { 
                                                                                        IStrategoTerm q_72 = null;
                                                                                        IStrategoTerm arg849 = term.getSubterm(0);
                                                                                        if(arg849.getTermType() != IStrategoTerm.APPL || Simplify._consNot_1 != ((IStrategoAppl)arg849).getConstructor())
                                                                                          break Fail313;
                                                                                        q_72 = arg849.getSubterm(0);
                                                                                        term = q_72;
                                                                                        if(true)
                                                                                          break Success256;
                                                                                      }
                                                                                      term = term429;
                                                                                    }
                                                                                    Success257:
                                                                                    { 
                                                                                      if(cons38 == Simplify._consIfElseExp_3)
                                                                                      { 
                                                                                        Fail314:
                                                                                        { 
                                                                                          IStrategoTerm p_72 = null;
                                                                                          IStrategoTerm arg850 = term.getSubterm(0);
                                                                                          if(arg850.getTermType() != IStrategoTerm.APPL || Simplify._consFalse_0 != ((IStrategoAppl)arg850).getConstructor())
                                                                                            break Fail314;
                                                                                          p_72 = term.getSubterm(2);
                                                                                          term = p_72;
                                                                                          if(true)
                                                                                            break Success257;
                                                                                        }
                                                                                        term = term429;
                                                                                      }
                                                                                      if(cons38 == Simplify._consIfElseExp_3)
                                                                                      { 
                                                                                        IStrategoTerm n_72 = null;
                                                                                        IStrategoTerm arg851 = term.getSubterm(0);
                                                                                        if(arg851.getTermType() != IStrategoTerm.APPL || Simplify._consTrue_0 != ((IStrategoAppl)arg851).getConstructor())
                                                                                          break Fail275;
                                                                                        n_72 = term.getSubterm(1);
                                                                                        term = n_72;
                                                                                      }
                                                                                      else
                                                                                      { 
                                                                                        break Fail275;
                                                                                      }
                                                                                    }
                                                                                  }
                                                                                }
                                                                              }
                                                                            }
                                                                          }
                                                                        }
                                                                      }
                                                                    }
                                                                  }
                                                                }
                                                              }
                                                            }
                                                          }
                                                        }
                                                      }
                                                    }
                                                  }
                                                }
                                              }
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class $Eval$Neg_0_0 extends Strategy 
  { 
    public static $Eval$Neg_0_0 instance = new $Eval$Neg_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      ITermFactory termFactory = context.getFactory();
      context.push("EvalNeg_0_0");
      Fail315:
      { 
        IStrategoTerm r_76 = null;
        if(term.getTermType() != IStrategoTerm.APPL || Simplify._consNeg_1 != ((IStrategoAppl)term).getConstructor())
          break Fail315;
        IStrategoTerm arg852 = term.getSubterm(0);
        if(arg852.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg852).getConstructor())
          break Fail315;
        r_76 = arg852.getSubterm(0);
        term = termFactory.makeTuple(Simplify.const53, r_76);
        term = subt$S_0_0.instance.invoke(context, term);
        if(term == null)
          break Fail315;
        term = termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{term});
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class compare_1_0 extends Strategy 
  { 
    public static compare_1_0 instance = new compare_1_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term, Strategy x_76)
    { 
      context.push("compare_1_0");
      Fail316:
      { 
        Success258:
        { 
          Fail317:
          { 
            IStrategoTerm w_76 = null;
            w_76 = term;
            term = x_76.invoke(context, term);
            if(term == null)
              break Fail317;
            term = w_76;
            { 
              term = Simplify.constTrue0;
              if(true)
                break Success258;
            }
          }
          term = Simplify.constFalse0;
        }
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class $Eval$Add0_0_0 extends Strategy 
  { 
    public static $Eval$Add0_0_0 instance = new $Eval$Add0_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail318:
      { 
        IStrategoTerm term470 = term;
        IStrategoConstructor cons39 = term.getTermType() == IStrategoTerm.APPL ? ((IStrategoAppl)term).getConstructor() : null;
        Success259:
        { 
          if(cons39 == Simplify._consAdd_2)
          { 
            Fail319:
            { 
              IStrategoTerm a_77 = null;
              a_77 = term.getSubterm(0);
              IStrategoTerm arg853 = term.getSubterm(1);
              if(arg853.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg853).getConstructor())
                break Fail319;
              IStrategoTerm arg854 = arg853.getSubterm(0);
              if(arg854.getTermType() != IStrategoTerm.STRING || !"0".equals(((IStrategoString)arg854).stringValue()))
                break Fail319;
              term = a_77;
              if(true)
                break Success259;
            }
            term = term470;
          }
          if(cons39 == Simplify._consAdd_2)
          { 
            IStrategoTerm z_76 = null;
            IStrategoTerm arg855 = term.getSubterm(0);
            if(arg855.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg855).getConstructor())
              break Fail318;
            IStrategoTerm arg856 = arg855.getSubterm(0);
            if(arg856.getTermType() != IStrategoTerm.STRING || !"0".equals(((IStrategoString)arg856).stringValue()))
              break Fail318;
            z_76 = term.getSubterm(1);
            term = z_76;
          }
          else
          { 
            break Fail318;
          }
        }
        if(true)
          return term;
      }
      context.push("EvalAdd0_0_0");
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class $Eval$Known$True_0_0 extends Strategy 
  { 
    public static $Eval$Known$True_0_0 instance = new $Eval$Known$True_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail320:
      { 
        if(term.getTermType() != IStrategoTerm.APPL || Simplify._consKnown_1 != ((IStrategoAppl)term).getConstructor())
          break Fail320;
        IStrategoTerm arg857 = term.getSubterm(0);
        if(arg857.getTermType() != IStrategoTerm.APPL || Simplify._consTrue_0 != ((IStrategoAppl)arg857).getConstructor())
          break Fail320;
        term = Simplify.constTrue0;
        if(true)
          return term;
      }
      context.push("EvalKnownTrue_0_0");
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class $Eval$Known$Other_0_0 extends Strategy 
  { 
    public static $Eval$Known$Other_0_0 instance = new $Eval$Known$Other_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail321:
      { 
        if(term.getTermType() != IStrategoTerm.APPL || Simplify._consKnown_1 != ((IStrategoAppl)term).getConstructor())
          break Fail321;
        term = Simplify.constFalse0;
        if(true)
          return term;
      }
      context.push("EvalKnownOther_0_0");
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class $Mul$Abs_0_0 extends Strategy 
  { 
    public static $Mul$Abs_0_0 instance = new $Mul$Abs_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      ITermFactory termFactory = context.getFactory();
      context.push("MulAbs_0_0");
      Fail322:
      { 
        IStrategoTerm d_77 = null;
        IStrategoTerm f_77 = null;
        if(term.getTermType() != IStrategoTerm.APPL || Simplify._consMul_2 != ((IStrategoAppl)term).getConstructor())
          break Fail322;
        d_77 = term.getSubterm(0);
        IStrategoTerm arg858 = term.getSubterm(1);
        if(arg858.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg858).getConstructor())
          break Fail322;
        f_77 = arg858.getSubterm(0);
        term = termFactory.makeTuple(f_77, Simplify.const53);
        term = lt$S_0_0.instance.invoke(context, term);
        if(term == null)
          break Fail322;
        term = termFactory.makeTuple(Simplify.const53, f_77);
        term = subt$S_0_0.instance.invoke(context, term);
        if(term == null)
          break Fail322;
        term = termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consNeg_1, new IStrategoTerm[]{d_77}), termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{term})});
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class $Sort$Mul_0_0 extends Strategy 
  { 
    public static $Sort$Mul_0_0 instance = new $Sort$Mul_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      ITermFactory termFactory = context.getFactory();
      context.push("SortMul_0_0");
      Fail323:
      { 
        IStrategoTerm term471 = term;
        IStrategoConstructor cons40 = term.getTermType() == IStrategoTerm.APPL ? ((IStrategoAppl)term).getConstructor() : null;
        Success260:
        { 
          if(cons40 == Simplify._consAdd_2)
          { 
            Fail324:
            { 
              IStrategoTerm t_77 = null;
              IStrategoTerm u_77 = null;
              IStrategoTerm w_77 = null;
              IStrategoTerm x_77 = null;
              IStrategoTerm arg859 = term.getSubterm(0);
              if(arg859.getTermType() != IStrategoTerm.APPL || Simplify._consMul_2 != ((IStrategoAppl)arg859).getConstructor())
                break Fail324;
              u_77 = arg859.getSubterm(0);
              IStrategoTerm arg860 = arg859.getSubterm(1);
              if(arg860.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg860).getConstructor())
                break Fail324;
              x_77 = arg860.getSubterm(0);
              IStrategoTerm arg861 = term.getSubterm(1);
              if(arg861.getTermType() != IStrategoTerm.APPL || Simplify._consMul_2 != ((IStrategoAppl)arg861).getConstructor())
                break Fail324;
              t_77 = arg861.getSubterm(0);
              IStrategoTerm arg862 = arg861.getSubterm(1);
              if(arg862.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg862).getConstructor())
                break Fail324;
              w_77 = arg862.getSubterm(0);
              term = termFactory.makeTuple(w_77, x_77);
              term = lt$S_0_0.instance.invoke(context, term);
              if(term == null)
                break Fail324;
              term = termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{t_77, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{w_77})}), termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{u_77, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{x_77})})});
              if(true)
                break Success260;
            }
            term = term471;
          }
          if(cons40 == Simplify._consAdd_2)
          { 
            IStrategoTerm k_77 = null;
            IStrategoTerm l_77 = null;
            IStrategoTerm n_77 = null;
            IStrategoTerm o_77 = null;
            IStrategoTerm q_77 = null;
            IStrategoTerm arg863 = term.getSubterm(0);
            if(arg863.getTermType() != IStrategoTerm.APPL || Simplify._consAdd_2 != ((IStrategoAppl)arg863).getConstructor())
              break Fail323;
            k_77 = arg863.getSubterm(0);
            IStrategoTerm arg864 = arg863.getSubterm(1);
            if(arg864.getTermType() != IStrategoTerm.APPL || Simplify._consMul_2 != ((IStrategoAppl)arg864).getConstructor())
              break Fail323;
            n_77 = arg864.getSubterm(0);
            IStrategoTerm arg865 = arg864.getSubterm(1);
            if(arg865.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg865).getConstructor())
              break Fail323;
            q_77 = arg865.getSubterm(0);
            IStrategoTerm arg866 = term.getSubterm(1);
            if(arg866.getTermType() != IStrategoTerm.APPL || Simplify._consMul_2 != ((IStrategoAppl)arg866).getConstructor())
              break Fail323;
            l_77 = arg866.getSubterm(0);
            IStrategoTerm arg867 = arg866.getSubterm(1);
            if(arg867.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg867).getConstructor())
              break Fail323;
            o_77 = arg867.getSubterm(0);
            term = termFactory.makeTuple(o_77, q_77);
            term = lt$S_0_0.instance.invoke(context, term);
            if(term == null)
              break Fail323;
            term = termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{k_77, termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{l_77, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{o_77})})}), termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{n_77, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{q_77})})});
          }
          else
          { 
            break Fail323;
          }
        }
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class $Combine$Mul_0_0 extends Strategy 
  { 
    public static $Combine$Mul_0_0 instance = new $Combine$Mul_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      ITermFactory termFactory = context.getFactory();
      Fail325:
      { 
        IStrategoTerm term472 = term;
        IStrategoConstructor cons41 = term.getTermType() == IStrategoTerm.APPL ? ((IStrategoAppl)term).getConstructor() : null;
        Success261:
        { 
          if(cons41 == Simplify._consAdd_2)
          { 
            Fail326:
            { 
              IStrategoTerm h_78 = null;
              IStrategoTerm i_78 = null;
              IStrategoTerm j_78 = null;
              IStrategoTerm arg868 = term.getSubterm(0);
              if(arg868.getTermType() != IStrategoTerm.APPL || Simplify._consMul_2 != ((IStrategoAppl)arg868).getConstructor())
                break Fail326;
              h_78 = arg868.getSubterm(0);
              IStrategoTerm arg869 = arg868.getSubterm(1);
              if(arg869.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg869).getConstructor())
                break Fail326;
              j_78 = arg869.getSubterm(0);
              IStrategoTerm arg870 = term.getSubterm(1);
              if(arg870.getTermType() != IStrategoTerm.APPL || Simplify._consMul_2 != ((IStrategoAppl)arg870).getConstructor())
                break Fail326;
              i_78 = arg870.getSubterm(0);
              IStrategoTerm arg871 = arg870.getSubterm(1);
              if(arg871.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg871).getConstructor())
                break Fail326;
              if(arg871.getSubterm(0) != j_78 && !j_78.match(arg871.getSubterm(0)))
                break Fail326;
              term = j_78;
              IStrategoTerm term473 = term;
              Success262:
              { 
                Fail327:
                { 
                  if(term.getTermType() != IStrategoTerm.STRING || !"1".equals(((IStrategoString)term).stringValue()))
                    break Fail327;
                  { 
                    if(true)
                      break Fail326;
                    if(true)
                      break Success262;
                  }
                }
                term = term473;
              }
              term = termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{h_78, i_78}), termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{j_78})});
              if(true)
                break Success261;
            }
            term = term472;
          }
          if(cons41 == Simplify._consAdd_2)
          { 
            IStrategoTerm a_78 = null;
            IStrategoTerm c_78 = null;
            IStrategoTerm d_78 = null;
            IStrategoTerm e_78 = null;
            IStrategoTerm arg872 = term.getSubterm(0);
            if(arg872.getTermType() != IStrategoTerm.APPL || Simplify._consAdd_2 != ((IStrategoAppl)arg872).getConstructor())
              break Fail325;
            a_78 = arg872.getSubterm(0);
            IStrategoTerm arg873 = arg872.getSubterm(1);
            if(arg873.getTermType() != IStrategoTerm.APPL || Simplify._consMul_2 != ((IStrategoAppl)arg873).getConstructor())
              break Fail325;
            c_78 = arg873.getSubterm(0);
            IStrategoTerm arg874 = arg873.getSubterm(1);
            if(arg874.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg874).getConstructor())
              break Fail325;
            e_78 = arg874.getSubterm(0);
            IStrategoTerm arg875 = term.getSubterm(1);
            if(arg875.getTermType() != IStrategoTerm.APPL || Simplify._consMul_2 != ((IStrategoAppl)arg875).getConstructor())
              break Fail325;
            d_78 = arg875.getSubterm(0);
            IStrategoTerm arg876 = arg875.getSubterm(1);
            if(arg876.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg876).getConstructor())
              break Fail325;
            if(arg876.getSubterm(0) != e_78 && !e_78.match(arg876.getSubterm(0)))
              break Fail325;
            term = e_78;
            IStrategoTerm term474 = term;
            Success263:
            { 
              Fail328:
              { 
                if(term.getTermType() != IStrategoTerm.STRING || !"1".equals(((IStrategoString)term).stringValue()))
                  break Fail328;
                { 
                  if(true)
                    break Fail325;
                  if(true)
                    break Success263;
                }
              }
              term = term474;
            }
            term = termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{a_78, termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{c_78, d_78}), termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{e_78})})});
          }
          else
          { 
            break Fail325;
          }
        }
        if(true)
          return term;
      }
      context.push("CombineMul_0_0");
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class $Eliminate$Mul1_0_0 extends Strategy 
  { 
    public static $Eliminate$Mul1_0_0 instance = new $Eliminate$Mul1_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      ITermFactory termFactory = context.getFactory();
      Fail329:
      { 
        IStrategoTerm term475 = term;
        IStrategoConstructor cons42 = term.getTermType() == IStrategoTerm.APPL ? ((IStrategoAppl)term).getConstructor() : null;
        Success264:
        { 
          if(cons42 == Simplify._consMul_2)
          { 
            Fail330:
            { 
              IStrategoTerm p_78 = null;
              p_78 = term.getSubterm(0);
              IStrategoTerm arg877 = term.getSubterm(1);
              if(arg877.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg877).getConstructor())
                break Fail330;
              IStrategoTerm arg878 = arg877.getSubterm(0);
              if(arg878.getTermType() != IStrategoTerm.STRING || !"1".equals(((IStrategoString)arg878).stringValue()))
                break Fail330;
              term = p_78;
              if(true)
                break Success264;
            }
            term = term475;
          }
          if(cons42 == Simplify._consMul_2)
          { 
            IStrategoTerm o_78 = null;
            o_78 = term.getSubterm(0);
            IStrategoTerm arg879 = term.getSubterm(1);
            if(arg879.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg879).getConstructor())
              break Fail329;
            IStrategoTerm arg880 = arg879.getSubterm(0);
            if(arg880.getTermType() != IStrategoTerm.STRING || !"-1".equals(((IStrategoString)arg880).stringValue()))
              break Fail329;
            term = termFactory.makeAppl(Simplify._consNeg_1, new IStrategoTerm[]{o_78});
          }
          else
          { 
            break Fail329;
          }
        }
        if(true)
          return term;
      }
      context.push("EliminateMul1_0_0");
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class add_assertions_0_0 extends Strategy 
  { 
    public static add_assertions_0_0 instance = new add_assertions_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      context.push("add_assertions_0_0");
      Fail331:
      { 
        term = topdown_1_0.instance.invoke(context, term, lifted149.instance);
        if(term == null)
          break Fail331;
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class remove_duplicate_assertions_0_0 extends Strategy 
  { 
    public static remove_duplicate_assertions_0_0 instance = new remove_duplicate_assertions_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      context.push("remove_duplicate_assertions_0_0");
      Fail332:
      { 
        term = topdown_1_0.instance.invoke(context, term, lifted151.instance);
        if(term == null)
          break Fail332;
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class $If$Assertion_0_0 extends Strategy 
  { 
    public static $If$Assertion_0_0 instance = new $If$Assertion_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      ITermFactory termFactory = context.getFactory();
      Fail333:
      { 
        IStrategoTerm term477 = term;
        IStrategoConstructor cons43 = term.getTermType() == IStrategoTerm.APPL ? ((IStrategoAppl)term).getConstructor() : null;
        Success265:
        { 
          if(cons43 == Simplify._consIf_2)
          { 
            Fail334:
            { 
              IStrategoTerm t_78 = null;
              IStrategoTerm u_78 = null;
              t_78 = term.getSubterm(0);
              IStrategoTerm arg881 = term.getSubterm(1);
              if(arg881.getTermType() != IStrategoTerm.APPL || Simplify._consStatements_1 != ((IStrategoAppl)arg881).getConstructor())
                break Fail334;
              IStrategoTerm arg882 = arg881.getSubterm(0);
              if(arg882.getTermType() != IStrategoTerm.LIST || ((IStrategoList)arg882).isEmpty())
                break Fail334;
              u_78 = ((IStrategoList)arg882).head();
              IStrategoTerm arg883 = ((IStrategoList)arg882).tail();
              if(arg883.getTermType() != IStrategoTerm.LIST || !((IStrategoList)arg883).isEmpty())
                break Fail334;
              term = termFactory.makeAppl(Simplify._consIf_2, new IStrategoTerm[]{t_78, termFactory.makeAppl(Simplify._consStatements_1, new IStrategoTerm[]{(IStrategoTerm)termFactory.makeListCons(termFactory.makeAppl(Simplify._consAssert_1, new IStrategoTerm[]{t_78}), termFactory.makeListCons(u_78, (IStrategoList)Simplify.constNil0))})});
              if(true)
                break Success265;
            }
            term = term477;
          }
          if(cons43 == Simplify._consIfElse_3)
          { 
            IStrategoTerm q_78 = null;
            IStrategoTerm r_78 = null;
            IStrategoTerm s_78 = null;
            r_78 = term.getSubterm(0);
            IStrategoTerm arg884 = term.getSubterm(1);
            if(arg884.getTermType() != IStrategoTerm.APPL || Simplify._consStatements_1 != ((IStrategoAppl)arg884).getConstructor())
              break Fail333;
            IStrategoTerm arg885 = arg884.getSubterm(0);
            if(arg885.getTermType() != IStrategoTerm.LIST || ((IStrategoList)arg885).isEmpty())
              break Fail333;
            q_78 = ((IStrategoList)arg885).head();
            IStrategoTerm arg886 = ((IStrategoList)arg885).tail();
            if(arg886.getTermType() != IStrategoTerm.LIST || !((IStrategoList)arg886).isEmpty())
              break Fail333;
            IStrategoTerm arg887 = term.getSubterm(2);
            if(arg887.getTermType() != IStrategoTerm.APPL || Simplify._consStatements_1 != ((IStrategoAppl)arg887).getConstructor())
              break Fail333;
            IStrategoTerm arg888 = arg887.getSubterm(0);
            if(arg888.getTermType() != IStrategoTerm.LIST || ((IStrategoList)arg888).isEmpty())
              break Fail333;
            s_78 = ((IStrategoList)arg888).head();
            IStrategoTerm arg889 = ((IStrategoList)arg888).tail();
            if(arg889.getTermType() != IStrategoTerm.LIST || !((IStrategoList)arg889).isEmpty())
              break Fail333;
            term = termFactory.makeAppl(Simplify._consIfElse_3, new IStrategoTerm[]{r_78, termFactory.makeAppl(Simplify._consStatements_1, new IStrategoTerm[]{(IStrategoTerm)termFactory.makeListCons(termFactory.makeAppl(Simplify._consAssert_1, new IStrategoTerm[]{r_78}), termFactory.makeListCons(q_78, (IStrategoList)Simplify.constNil0))}), termFactory.makeAppl(Simplify._consStatements_1, new IStrategoTerm[]{(IStrategoTerm)termFactory.makeListCons(termFactory.makeAppl(Simplify._consAssert_1, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consNot_1, new IStrategoTerm[]{r_78})}), termFactory.makeListCons(s_78, (IStrategoList)Simplify.constNil0))})});
          }
          else
          { 
            break Fail333;
          }
        }
        if(true)
          return term;
      }
      context.push("IfAssertion_0_0");
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class $For$Assertion_0_0 extends Strategy 
  { 
    public static $For$Assertion_0_0 instance = new $For$Assertion_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      ITermFactory termFactory = context.getFactory();
      Fail335:
      { 
        IStrategoTerm v_78 = null;
        IStrategoTerm w_78 = null;
        IStrategoTerm x_78 = null;
        IStrategoTerm y_78 = null;
        if(term.getTermType() != IStrategoTerm.APPL || Simplify._consFor_4 != ((IStrategoAppl)term).getConstructor())
          break Fail335;
        w_78 = term.getSubterm(0);
        v_78 = term.getSubterm(1);
        x_78 = term.getSubterm(2);
        y_78 = term.getSubterm(3);
        term = termFactory.makeAppl(Simplify._consFor_4, new IStrategoTerm[]{w_78, v_78, x_78, termFactory.makeAppl(Simplify._consStatements_1, new IStrategoTerm[]{(IStrategoTerm)termFactory.makeListCons(termFactory.makeAppl(Simplify._consAssert_1, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consAnd_2, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consGeq_2, new IStrategoTerm[]{w_78, v_78}), termFactory.makeAppl(Simplify._consLeq_2, new IStrategoTerm[]{w_78, x_78})})}), termFactory.makeListCons(y_78, (IStrategoList)Simplify.constNil0))})});
        if(true)
          return term;
      }
      context.push("ForAssertion_0_0");
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class $Remove$Duplicate$Assertion_0_0 extends Strategy 
  { 
    public static $Remove$Duplicate$Assertion_0_0 instance = new $Remove$Duplicate$Assertion_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      ITermFactory termFactory = context.getFactory();
      Fail336:
      { 
        IStrategoTerm z_78 = null;
        IStrategoTerm a_79 = null;
        if(term.getTermType() != IStrategoTerm.APPL || Simplify._consStatements_1 != ((IStrategoAppl)term).getConstructor())
          break Fail336;
        IStrategoTerm arg890 = term.getSubterm(0);
        if(arg890.getTermType() != IStrategoTerm.LIST || ((IStrategoList)arg890).isEmpty())
          break Fail336;
        IStrategoTerm arg891 = ((IStrategoList)arg890).head();
        if(arg891.getTermType() != IStrategoTerm.APPL || Simplify._consAssert_1 != ((IStrategoAppl)arg891).getConstructor())
          break Fail336;
        z_78 = arg891.getSubterm(0);
        IStrategoTerm arg892 = ((IStrategoList)arg890).tail();
        if(arg892.getTermType() != IStrategoTerm.LIST || ((IStrategoList)arg892).isEmpty())
          break Fail336;
        IStrategoTerm arg893 = ((IStrategoList)arg892).head();
        if(arg893.getTermType() != IStrategoTerm.APPL || Simplify._consStatements_1 != ((IStrategoAppl)arg893).getConstructor())
          break Fail336;
        IStrategoTerm arg894 = arg893.getSubterm(0);
        if(arg894.getTermType() != IStrategoTerm.LIST || ((IStrategoList)arg894).isEmpty())
          break Fail336;
        IStrategoTerm arg895 = ((IStrategoList)arg894).head();
        if(arg895.getTermType() != IStrategoTerm.APPL || Simplify._consAssert_1 != ((IStrategoAppl)arg895).getConstructor())
          break Fail336;
        if(arg895.getSubterm(0) != z_78 && !z_78.match(arg895.getSubterm(0)))
          break Fail336;
        IStrategoTerm arg896 = ((IStrategoList)arg894).tail();
        if(arg896.getTermType() != IStrategoTerm.LIST || ((IStrategoList)arg896).isEmpty())
          break Fail336;
        a_79 = ((IStrategoList)arg896).head();
        IStrategoTerm arg897 = ((IStrategoList)arg896).tail();
        if(arg897.getTermType() != IStrategoTerm.LIST || !((IStrategoList)arg897).isEmpty())
          break Fail336;
        IStrategoTerm arg898 = ((IStrategoList)arg892).tail();
        if(arg898.getTermType() != IStrategoTerm.LIST || !((IStrategoList)arg898).isEmpty())
          break Fail336;
        term = termFactory.makeAppl(Simplify._consStatements_1, new IStrategoTerm[]{(IStrategoTerm)termFactory.makeListCons(termFactory.makeAppl(Simplify._consAssert_1, new IStrategoTerm[]{z_78}), termFactory.makeListCons(a_79, (IStrategoList)Simplify.constNil0))});
        if(true)
          return term;
      }
      context.push("RemoveDuplicateAssertion_0_0");
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class debug_simplify_0_0 extends Strategy 
  { 
    public static debug_simplify_0_0 instance = new debug_simplify_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail337:
      { 
        if(true)
          return term;
      }
      context.push("debug_simplify_0_0");
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class io_$Simplify_0_0 extends Strategy 
  { 
    public static io_$Simplify_0_0 instance = new io_$Simplify_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      context.push("io_Simplify_0_0");
      Fail338:
      { 
        term = options_io_wrap_1_0.instance.invoke(context, term, simplify_0_0.instance);
        if(term == null)
          break Fail338;
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class simplify_0_0 extends Strategy 
  { 
    public static simplify_0_0 instance = new simplify_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      context.push("simplify_0_0");
      Fail339:
      { 
        IStrategoTerm term478 = term;
        Success266:
        { 
          Fail340:
          { 
            term = add_assertions_0_0.instance.invoke(context, term);
            if(term == null)
              break Fail340;
            if(true)
              break Success266;
          }
          term = term478;
          IStrategoTerm b_79 = null;
          b_79 = term;
          term = debug_0_0.instance.invoke(context, Simplify.const112);
          if(term == null)
            break Fail339;
          term = b_79;
        }
        IStrategoTerm term479 = term;
        Success267:
        { 
          Fail341:
          { 
            term = propagate_constant_0_0.instance.invoke(context, term);
            if(term == null)
              break Fail341;
            if(true)
              break Success267;
          }
          term = term479;
          IStrategoTerm c_79 = null;
          c_79 = term;
          term = debug_0_0.instance.invoke(context, Simplify.const113);
          if(term == null)
            break Fail339;
          term = c_79;
        }
        IStrategoTerm term480 = term;
        Success268:
        { 
          Fail342:
          { 
            term = beautify_0_0.instance.invoke(context, term);
            if(term == null)
              break Fail342;
            if(true)
              break Success268;
          }
          term = term480;
          IStrategoTerm e_79 = null;
          e_79 = term;
          term = debug_0_0.instance.invoke(context, Simplify.const114);
          if(term == null)
            break Fail339;
          term = e_79;
        }
        IStrategoTerm term481 = term;
        Success269:
        { 
          Fail343:
          { 
            term = remove_duplicate_assertions_0_0.instance.invoke(context, term);
            if(term == null)
              break Fail343;
            if(true)
              break Success269;
          }
          term = term481;
          IStrategoTerm f_79 = null;
          f_79 = term;
          term = debug_0_0.instance.invoke(context, Simplify.const115);
          if(term == null)
            break Fail339;
          term = f_79;
        }
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class propagate_constant_0_0 extends Strategy 
  { 
    public static propagate_constant_0_0 instance = new propagate_constant_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      context.push("propagate_constant_0_0");
      Fail344:
      { 
        IStrategoTerm term482 = term;
        Success270:
        { 
          Fail345:
          { 
            term = $Propagate$Constant_0_0.instance.invoke(context, term);
            if(term == null)
              break Fail345;
            if(true)
              break Success270;
          }
          term = term482;
          IStrategoTerm term483 = term;
          Success271:
          { 
            Fail346:
            { 
              term = propagate_constant_assign_0_0.instance.invoke(context, term);
              if(term == null)
                break Fail346;
              if(true)
                break Success271;
            }
            term = term483;
            IStrategoTerm term484 = term;
            Success272:
            { 
              Fail347:
              { 
                term = propagate_constant_assert_0_0.instance.invoke(context, term);
                if(term == null)
                  break Fail347;
                if(true)
                  break Success272;
              }
              term = term484;
              IStrategoTerm term485 = term;
              Success273:
              { 
                Fail348:
                { 
                  term = propagate_constant_cassign_0_0.instance.invoke(context, term);
                  if(term == null)
                    break Fail348;
                  if(true)
                    break Success273;
                }
                term = term485;
                IStrategoTerm term486 = term;
                Success274:
                { 
                  Fail349:
                  { 
                    term = propagate_constant_if_0_0.instance.invoke(context, term);
                    if(term == null)
                      break Fail349;
                    if(true)
                      break Success274;
                  }
                  term = term486;
                  IStrategoTerm term487 = term;
                  Success275:
                  { 
                    Fail350:
                    { 
                      term = propagate_constant_ifknown_0_0.instance.invoke(context, term);
                      if(term == null)
                        break Fail350;
                      if(true)
                        break Success275;
                    }
                    term = term487;
                    IStrategoTerm term488 = term;
                    Success276:
                    { 
                      Fail351:
                      { 
                        term = propagate_constant_while_0_0.instance.invoke(context, term);
                        if(term == null)
                          break Fail351;
                        if(true)
                          break Success276;
                      }
                      term = term488;
                      IStrategoTerm term489 = term;
                      Success277:
                      { 
                        Fail352:
                        { 
                          term = propagate_constant_for_0_0.instance.invoke(context, term);
                          if(term == null)
                            break Fail352;
                          if(true)
                            break Success277;
                        }
                        term = term489;
                        IStrategoTerm term490 = term;
                        Success278:
                        { 
                          Fail353:
                          { 
                            term = propagate_constant_cfor_0_0.instance.invoke(context, term);
                            if(term == null)
                              break Fail353;
                            if(true)
                              break Success278;
                          }
                          term = term490;
                          IStrategoTerm term491 = term;
                          Success279:
                          { 
                            Fail354:
                            { 
                              term = propagate_constant_procedure_0_0.instance.invoke(context, term);
                              if(term == null)
                                break Fail354;
                              if(true)
                                break Success279;
                            }
                            term = term491;
                            IStrategoTerm term492 = term;
                            Success280:
                            { 
                              Fail355:
                              { 
                                term = propagate_constant_declarations_0_0.instance.invoke(context, term);
                                if(term == null)
                                  break Fail355;
                                if(true)
                                  break Success280;
                              }
                              term = SRTS_all.instance.invoke(context, term492, propagate_constant_0_0.instance);
                              if(term == null)
                                break Fail344;
                              term = try_1_0.instance.invoke(context, term, normalise_0_0.instance);
                              if(term == null)
                                break Fail344;
                              term = try_assertion_0_0.instance.invoke(context, term);
                              if(term == null)
                                break Fail344;
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class propagate_constant_assign_0_0 extends Strategy 
  { 
    public static propagate_constant_assign_0_0 instance = new propagate_constant_assign_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      ITermFactory termFactory = context.getFactory();
      context.push("propagate_constant_assign_0_0");
      Fail356:
      { 
        TermReference j_79 = new TermReference();
        TermReference m_79 = new TermReference();
        IStrategoTerm n_79 = null;
        lifted158 lifted1580 = new lifted158();
        lifted156 lifted1560 = new lifted156();
        lifted1580.j_79 = j_79;
        lifted1560.m_79 = m_79;
        term = $Assign_2_0.instance.invoke(context, term, lifted1560, lifted1580);
        if(term == null)
          break Fail356;
        n_79 = term;
        if(m_79.value == null)
          break Fail356;
        term = termFactory.makeAppl(Simplify._consVar_1, new IStrategoTerm[]{m_79.value});
        term = undefine_assertions_0_0.instance.invoke(context, term);
        if(term == null)
          break Fail356;
        term = n_79;
        IStrategoTerm term493 = term;
        Success281:
        { 
          Fail357:
          { 
            IStrategoTerm o_79 = null;
            IStrategoTerm u_79 = null;
            o_79 = term;
            u_79 = term;
            term = get_option_0_1.instance.invoke(context, u_79, Simplify.constPropagate_constant_assignments0);
            if(term == null)
              break Fail357;
            if(j_79.value == null)
              break Fail357;
            term = is_value_0_0.instance.invoke(context, j_79.value);
            if(term == null)
              break Fail357;
            term = o_79;
            { 
              IStrategoTerm p_79 = null;
              IStrategoTerm v_79 = null;
              IStrategoTerm w_79 = null;
              IStrategoTerm y_79 = null;
              IStrategoTerm z_79 = null;
              IStrategoTerm a_80 = null;
              p_79 = term;
              y_79 = term;
              v_79 = Simplify.const116;
              term = y_79;
              z_79 = y_79;
              if(m_79.value == null)
                break Fail356;
              term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consVar_1, new IStrategoTerm[]{m_79.value}), checkListAnnos(termFactory, Simplify.constCons16));
              w_79 = term;
              term = z_79;
              a_80 = z_79;
              if(j_79.value == null)
                break Fail356;
              term = termFactory.makeTuple(Simplify.const117, j_79.value);
              term = dr_set_rule_0_3.instance.invoke(context, a_80, v_79, w_79, term);
              if(term == null)
                break Fail356;
              term = p_79;
              if(true)
                break Success281;
            }
          }
          term = term493;
          IStrategoTerm s_79 = null;
          IStrategoTerm b_80 = null;
          IStrategoTerm d_80 = null;
          IStrategoTerm e_80 = null;
          s_79 = term;
          d_80 = term;
          b_80 = Simplify.const116;
          term = d_80;
          e_80 = d_80;
          if(m_79.value == null)
            break Fail356;
          term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consVar_1, new IStrategoTerm[]{m_79.value}), checkListAnnos(termFactory, Simplify.constCons16));
          term = dr_undefine_rule_0_2.instance.invoke(context, e_80, b_80, term);
          if(term == null)
            break Fail356;
          term = s_79;
        }
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class propagate_constant_assert_0_0 extends Strategy 
  { 
    public static propagate_constant_assert_0_0 instance = new propagate_constant_assert_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      context.push("propagate_constant_assert_0_0");
      Fail358:
      { 
        IStrategoTerm f_80 = null;
        if(term.getTermType() != IStrategoTerm.APPL || Simplify._consAssert_1 != ((IStrategoAppl)term).getConstructor())
          break Fail358;
        f_80 = term;
        IStrategoTerm term494 = term;
        Success282:
        { 
          Fail359:
          { 
            term = $Assert_1_0.instance.invoke(context, term, propagate_constant_assertion_0_0.instance);
            if(term == null)
              break Fail359;
            if(true)
              break Success282;
          }
          term = term494;
        }
        term = f_80;
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class propagate_constant_assertion_0_0 extends Strategy 
  { 
    public static propagate_constant_assertion_0_0 instance = new propagate_constant_assertion_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      ITermFactory termFactory = context.getFactory();
      context.push("propagate_constant_assertion_0_0");
      Fail360:
      { 
        IStrategoTerm g_80 = null;
        IStrategoTerm term495 = term;
        Success283:
        { 
          Fail361:
          { 
            term = propagate_constant_assertion_and_0_0.instance.invoke(context, term);
            if(term == null)
              break Fail361;
            if(true)
              break Success283;
          }
          term = term495;
          IStrategoTerm j_80 = null;
          term = debug_simplify_0_0.instance.invoke(context, term);
          if(term == null)
            break Fail360;
          g_80 = term;
          term = propagate_constant_0_0.instance.invoke(context, term);
          if(term == null)
            break Fail360;
          j_80 = term;
          term = (IStrategoTerm)termFactory.makeListCons(Simplify.const118, termFactory.makeListCons(term, (IStrategoList)Simplify.constNil0));
          term = debug_simplify_0_0.instance.invoke(context, term);
          if(term == null)
            break Fail360;
          term = define_assertion_0_1.instance.invoke(context, j_80, g_80);
          if(term == null)
            break Fail360;
        }
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class propagate_constant_assertion_and_0_0 extends Strategy 
  { 
    public static propagate_constant_assertion_and_0_0 instance = new propagate_constant_assertion_and_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      context.push("propagate_constant_assertion_and_0_0");
      Fail362:
      { 
        if(term.getTermType() != IStrategoTerm.APPL || Simplify._consAnd_2 != ((IStrategoAppl)term).getConstructor())
          break Fail362;
        term = $And_2_0.instance.invoke(context, term, propagate_constant_assertion_0_0.instance, propagate_constant_assertion_0_0.instance);
        if(term == null)
          break Fail362;
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class propagate_constant_cassign_0_0 extends Strategy 
  { 
    public static propagate_constant_cassign_0_0 instance = new propagate_constant_cassign_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      ITermFactory termFactory = context.getFactory();
      context.push("propagate_constant_cassign_0_0");
      Fail363:
      { 
        TermReference o_80 = new TermReference();
        TermReference p_80 = new TermReference();
        IStrategoTerm q_80 = null;
        lifted164 lifted1640 = new lifted164();
        lifted162 lifted1620 = new lifted162();
        lifted1640.o_80 = o_80;
        lifted1620.p_80 = p_80;
        term = $C$Assign_2_0.instance.invoke(context, term, lifted1620, lifted1640);
        if(term == null)
          break Fail363;
        q_80 = term;
        if(p_80.value == null)
          break Fail363;
        term = termFactory.makeAppl(Simplify._consVar_1, new IStrategoTerm[]{p_80.value});
        term = undefine_assertions_0_0.instance.invoke(context, term);
        if(term == null)
          break Fail363;
        term = q_80;
        IStrategoTerm term496 = term;
        Success284:
        { 
          Fail364:
          { 
            IStrategoTerm r_80 = null;
            IStrategoTerm z_80 = null;
            r_80 = term;
            z_80 = term;
            term = get_option_0_1.instance.invoke(context, z_80, Simplify.constPropagate_constant_assignments0);
            if(term == null)
              break Fail364;
            if(o_80.value == null)
              break Fail364;
            term = is_value_0_0.instance.invoke(context, o_80.value);
            if(term == null)
              break Fail364;
            term = r_80;
            { 
              IStrategoTerm s_80 = null;
              IStrategoTerm a_81 = null;
              IStrategoTerm b_81 = null;
              IStrategoTerm d_81 = null;
              IStrategoTerm e_81 = null;
              IStrategoTerm f_81 = null;
              s_80 = term;
              d_81 = term;
              a_81 = Simplify.const116;
              term = d_81;
              e_81 = d_81;
              if(p_80.value == null)
                break Fail363;
              term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consVar_1, new IStrategoTerm[]{p_80.value}), checkListAnnos(termFactory, Simplify.constCons16));
              b_81 = term;
              term = e_81;
              f_81 = e_81;
              if(o_80.value == null)
                break Fail363;
              term = termFactory.makeTuple(Simplify.const117, o_80.value);
              term = dr_set_rule_0_3.instance.invoke(context, f_81, a_81, b_81, term);
              if(term == null)
                break Fail363;
              term = s_80;
              if(true)
                break Success284;
            }
          }
          term = term496;
          IStrategoTerm t_80 = null;
          IStrategoTerm g_81 = null;
          IStrategoTerm i_81 = null;
          IStrategoTerm j_81 = null;
          t_80 = term;
          i_81 = term;
          g_81 = Simplify.const116;
          term = i_81;
          j_81 = i_81;
          if(p_80.value == null)
            break Fail363;
          term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consVar_1, new IStrategoTerm[]{p_80.value}), checkListAnnos(termFactory, Simplify.constCons16));
          term = dr_undefine_rule_0_2.instance.invoke(context, j_81, g_81, term);
          if(term == null)
            break Fail363;
          term = t_80;
        }
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class propagate_constant_if_0_0 extends Strategy 
  { 
    public static propagate_constant_if_0_0 instance = new propagate_constant_if_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      context.push("propagate_constant_if_0_0");
      Fail365:
      { 
        IStrategoTerm term497 = term;
        Success285:
        { 
          Fail366:
          { 
            term = $If_2_0.instance.invoke(context, term, propagate_constant_0_0.instance, _Id.instance);
            if(term == null)
              break Fail366;
            IStrategoTerm term498 = term;
            Success286:
            { 
              Fail367:
              { 
                term = $Eval$If_0_0.instance.invoke(context, term);
                if(term == null)
                  break Fail367;
                term = propagate_constant_0_0.instance.invoke(context, term);
                if(term == null)
                  break Fail367;
                if(true)
                  break Success286;
              }
              term = term498;
              IStrategoTerm q_81 = null;
              q_81 = term;
              term = dr_fork_and_intersect_2_1.instance.invoke(context, q_81, lifted167.instance, _Id.instance, Simplify.constCons24);
              if(term == null)
                break Fail366;
            }
            if(true)
              break Success285;
          }
          term = term497;
          IStrategoTerm term499 = term;
          Success287:
          { 
            Fail368:
            { 
              term = $If$Else_3_0.instance.invoke(context, term, propagate_constant_0_0.instance, _Id.instance, _Id.instance);
              if(term == null)
                break Fail368;
              IStrategoTerm term500 = term;
              Success288:
              { 
                Fail369:
                { 
                  term = $Eval$If_0_0.instance.invoke(context, term);
                  if(term == null)
                    break Fail369;
                  term = propagate_constant_0_0.instance.invoke(context, term);
                  if(term == null)
                    break Fail369;
                  if(true)
                    break Success288;
                }
                term = term500;
                IStrategoTerm n_81 = null;
                n_81 = term;
                term = dr_fork_and_intersect_2_1.instance.invoke(context, n_81, lifted174.instance, lifted178.instance, Simplify.constCons24);
                if(term == null)
                  break Fail368;
              }
              if(true)
                break Success287;
            }
            term = term499;
            if(term.getTermType() != IStrategoTerm.APPL || Simplify._consIfElseExp_3 != ((IStrategoAppl)term).getConstructor())
              break Fail365;
            term = $If$Else$Exp_3_0.instance.invoke(context, term, lifted182.instance, _Id.instance, _Id.instance);
            if(term == null)
              break Fail365;
            IStrategoTerm term501 = term;
            Success289:
            { 
              Fail370:
              { 
                term = $Eval$If_0_0.instance.invoke(context, term);
                if(term == null)
                  break Fail370;
                term = propagate_constant_0_0.instance.invoke(context, term);
                if(term == null)
                  break Fail370;
                if(true)
                  break Success289;
              }
              term = term501;
              IStrategoTerm l_81 = null;
              l_81 = term;
              term = dr_fork_and_intersect_2_1.instance.invoke(context, l_81, lifted186.instance, lifted190.instance, Simplify.constCons24);
              if(term == null)
                break Fail365;
            }
          }
        }
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class propagate_constant_ifknown_0_0 extends Strategy 
  { 
    public static propagate_constant_ifknown_0_0 instance = new propagate_constant_ifknown_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      context.push("propagate_constant_ifknown_0_0");
      Fail371:
      { 
        term = $If$Known$Exp_3_0.instance.invoke(context, term, propagate_constant_0_0.instance, _Id.instance, _Id.instance);
        if(term == null)
          break Fail371;
        term = solve_ifknown_0_0.instance.invoke(context, term);
        if(term == null)
          break Fail371;
        term = propagate_constant_0_0.instance.invoke(context, term);
        if(term == null)
          break Fail371;
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class propagate_constant_while_0_0 extends Strategy 
  { 
    public static propagate_constant_while_0_0 instance = new propagate_constant_while_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      context.push("propagate_constant_while_0_0");
      Fail372:
      { 
        term = $While_2_0.instance.invoke(context, term, _Id.instance, _Id.instance);
        if(term == null)
          break Fail372;
        IStrategoTerm term502 = term;
        Success290:
        { 
          Fail373:
          { 
            term = $While_2_0.instance.invoke(context, term, propagate_constant_0_0.instance, _Id.instance);
            if(term == null)
              break Fail373;
            term = $Eval$While_0_0.instance.invoke(context, term);
            if(term == null)
              break Fail373;
            term = propagate_constant_0_0.instance.invoke(context, term);
            if(term == null)
              break Fail373;
            if(true)
              break Success290;
          }
          term = term502;
          IStrategoTerm s_81 = null;
          s_81 = term;
          term = dr_fix_and_intersect_1_1.instance.invoke(context, s_81, lifted201.instance, Simplify.constCons24);
          if(term == null)
            break Fail372;
        }
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class propagate_constant_for_0_0 extends Strategy 
  { 
    public static propagate_constant_for_0_0 instance = new propagate_constant_for_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      ITermFactory termFactory = context.getFactory();
      context.push("propagate_constant_for_0_0");
      Fail374:
      { 
        IStrategoTerm v_81 = null;
        IStrategoTerm w_81 = null;
        TermReference x_81 = new TermReference();
        TermReference y_81 = new TermReference();
        IStrategoTerm b_82 = null;
        IStrategoTerm f_82 = null;
        lifted204 lifted2040 = new lifted204();
        lifted2040.x_81 = x_81;
        term = $For_4_0.instance.invoke(context, term, lifted2040, _Id.instance, _Id.instance, _Id.instance);
        if(term == null)
          break Fail374;
        term = $For_4_0.instance.invoke(context, term, _Id.instance, propagate_constant_0_0.instance, propagate_constant_0_0.instance, _Id.instance);
        if(term == null)
          break Fail374;
        if(term.getTermType() != IStrategoTerm.APPL || Simplify._consFor_4 != ((IStrategoAppl)term).getConstructor())
          break Fail374;
        if(y_81.value == null)
          y_81.value = term.getSubterm(0);
        else
          if(y_81.value != term.getSubterm(0) && !y_81.value.match(term.getSubterm(0)))
            break Fail374;
        v_81 = term.getSubterm(1);
        w_81 = term.getSubterm(2);
        b_82 = term;
        if(y_81.value == null)
          break Fail374;
        term = (IStrategoTerm)termFactory.makeListCons(Simplify.const119, termFactory.makeListCons(y_81.value, termFactory.makeListCons(v_81, termFactory.makeListCons(w_81, (IStrategoList)Simplify.constNil0))));
        term = debug_simplify_0_0.instance.invoke(context, term);
        if(term == null)
          break Fail374;
        term = b_82;
        IStrategoTerm term503 = term;
        Success291:
        { 
          Fail375:
          { 
            term = $Eval$For_0_0.instance.invoke(context, term);
            if(term == null)
              break Fail375;
            term = propagate_constant_0_0.instance.invoke(context, term);
            if(term == null)
              break Fail375;
            if(true)
              break Success291;
          }
          term = term503;
          IStrategoTerm k_82 = null;
          IStrategoTerm l_82 = null;
          l_82 = term;
          k_82 = Simplify.constCons24;
          term = l_82;
          lifted212 lifted2120 = new lifted212();
          lifted2120.x_81 = x_81;
          lifted2120.y_81 = y_81;
          term = dr_fix_and_intersect_1_1.instance.invoke(context, term, lifted2120, k_82);
          if(term == null)
            break Fail374;
        }
        f_82 = term;
        if(y_81.value == null)
          break Fail374;
        term = (IStrategoTerm)termFactory.makeListCons(Simplify.const121, termFactory.makeListCons(y_81.value, (IStrategoList)Simplify.constNil0));
        term = debug_simplify_0_0.instance.invoke(context, term);
        if(term == null)
          break Fail374;
        term = f_82;
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class propagate_constant_cfor_0_0 extends Strategy 
  { 
    public static propagate_constant_cfor_0_0 instance = new propagate_constant_cfor_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      context.push("propagate_constant_cfor_0_0");
      Fail376:
      { 
        term = $C$For_4_0.instance.invoke(context, term, propagate_constant_0_0.instance, _Id.instance, _Id.instance, _Id.instance);
        if(term == null)
          break Fail376;
        IStrategoTerm term504 = term;
        Success292:
        { 
          Fail377:
          { 
            term = $C$For_4_0.instance.invoke(context, term, _Id.instance, propagate_constant_0_0.instance, _Id.instance, _Id.instance);
            if(term == null)
              break Fail377;
            term = $Eval$C$For_0_0.instance.invoke(context, term);
            if(term == null)
              break Fail377;
            term = propagate_constant_0_0.instance.invoke(context, term);
            if(term == null)
              break Fail377;
            if(true)
              break Success292;
          }
          term = term504;
          IStrategoTerm r_82 = null;
          r_82 = term;
          term = dr_fix_and_intersect_1_1.instance.invoke(context, r_82, lifted225.instance, Simplify.constCons24);
          if(term == null)
            break Fail376;
        }
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class propagate_constant_procedure_0_0 extends Strategy 
  { 
    public static propagate_constant_procedure_0_0 instance = new propagate_constant_procedure_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      context.push("propagate_constant_procedure_0_0");
      Fail378:
      { 
        IStrategoTerm z_82 = null;
        if(term.getTermType() != IStrategoTerm.APPL || Simplify._consProcedure_5 != ((IStrategoAppl)term).getConstructor())
          break Fail378;
        z_82 = term;
        term = dr_scope_1_1.instance.invoke(context, z_82, lifted234.instance, Simplify.const116);
        if(term == null)
          break Fail378;
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class propagate_constant_declarations_0_0 extends Strategy 
  { 
    public static propagate_constant_declarations_0_0 instance = new propagate_constant_declarations_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail379:
      { 
        if(term.getTermType() != IStrategoTerm.APPL || Simplify._consDeclarations_1 != ((IStrategoAppl)term).getConstructor())
          break Fail379;
        if(true)
          return term;
      }
      context.push("propagate_constant_declarations_0_0");
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class is_value_0_0 extends Strategy 
  { 
    public static is_value_0_0 instance = new is_value_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail380:
      { 
        if(term.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)term).getConstructor())
          break Fail380;
        if(true)
          return term;
      }
      context.push("is_value_0_0");
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class solve_ifknown_0_0 extends Strategy 
  { 
    public static solve_ifknown_0_0 instance = new solve_ifknown_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      context.push("solve_ifknown_0_0");
      Fail381:
      { 
        IStrategoTerm term505 = term;
        Success293:
        { 
          Fail382:
          { 
            term = $Eval$If$Known$True_0_0.instance.invoke(context, term);
            if(term == null)
              break Fail382;
            if(true)
              break Success293;
          }
          term = $Eval$If$Known$Other_0_0.instance.invoke(context, term505);
          if(term == null)
            break Fail381;
        }
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class $Eval$If_0_0 extends Strategy 
  { 
    public static $Eval$If_0_0 instance = new $Eval$If_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail383:
      { 
        IStrategoTerm term506 = term;
        IStrategoConstructor cons44 = term.getTermType() == IStrategoTerm.APPL ? ((IStrategoAppl)term).getConstructor() : null;
        Success294:
        { 
          if(cons44 == Simplify._consIf_2)
          { 
            Fail384:
            { 
              IStrategoTerm arg906 = term.getSubterm(0);
              if(arg906.getTermType() != IStrategoTerm.APPL || Simplify._consFalse_0 != ((IStrategoAppl)arg906).getConstructor())
                break Fail384;
              term = Simplify.constStatements0;
              if(true)
                break Success294;
            }
            term = term506;
          }
          Success295:
          { 
            if(cons44 == Simplify._consIfElse_3)
            { 
              Fail385:
              { 
                IStrategoTerm i_84 = null;
                IStrategoTerm arg907 = term.getSubterm(0);
                if(arg907.getTermType() != IStrategoTerm.APPL || Simplify._consFalse_0 != ((IStrategoAppl)arg907).getConstructor())
                  break Fail385;
                i_84 = term.getSubterm(2);
                term = i_84;
                if(true)
                  break Success295;
              }
              term = term506;
            }
            Success296:
            { 
              if(cons44 == Simplify._consIfElseExp_3)
              { 
                Fail386:
                { 
                  IStrategoTerm e_84 = null;
                  IStrategoTerm arg908 = term.getSubterm(0);
                  if(arg908.getTermType() != IStrategoTerm.APPL || Simplify._consFalse_0 != ((IStrategoAppl)arg908).getConstructor())
                    break Fail386;
                  e_84 = term.getSubterm(2);
                  term = e_84;
                  if(true)
                    break Success296;
                }
                term = term506;
              }
              Success297:
              { 
                if(cons44 == Simplify._consIf_2)
                { 
                  Fail387:
                  { 
                    IStrategoTerm c_84 = null;
                    IStrategoTerm arg909 = term.getSubterm(0);
                    if(arg909.getTermType() != IStrategoTerm.APPL || Simplify._consTrue_0 != ((IStrategoAppl)arg909).getConstructor())
                      break Fail387;
                    c_84 = term.getSubterm(1);
                    term = c_84;
                    if(true)
                      break Success297;
                  }
                  term = term506;
                }
                Success298:
                { 
                  if(cons44 == Simplify._consIfElse_3)
                  { 
                    Fail388:
                    { 
                      IStrategoTerm b_84 = null;
                      IStrategoTerm arg910 = term.getSubterm(0);
                      if(arg910.getTermType() != IStrategoTerm.APPL || Simplify._consTrue_0 != ((IStrategoAppl)arg910).getConstructor())
                        break Fail388;
                      b_84 = term.getSubterm(1);
                      term = b_84;
                      if(true)
                        break Success298;
                    }
                    term = term506;
                  }
                  if(cons44 == Simplify._consIfElseExp_3)
                  { 
                    IStrategoTerm z_83 = null;
                    IStrategoTerm arg911 = term.getSubterm(0);
                    if(arg911.getTermType() != IStrategoTerm.APPL || Simplify._consTrue_0 != ((IStrategoAppl)arg911).getConstructor())
                      break Fail383;
                    z_83 = term.getSubterm(1);
                    term = z_83;
                  }
                  else
                  { 
                    break Fail383;
                  }
                }
              }
            }
          }
        }
        if(true)
          return term;
      }
      context.push("EvalIf_0_0");
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class $Eval$While_0_0 extends Strategy 
  { 
    public static $Eval$While_0_0 instance = new $Eval$While_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail389:
      { 
        if(term.getTermType() != IStrategoTerm.APPL || Simplify._consWhile_2 != ((IStrategoAppl)term).getConstructor())
          break Fail389;
        IStrategoTerm arg912 = term.getSubterm(0);
        if(arg912.getTermType() != IStrategoTerm.APPL || Simplify._consFalse_0 != ((IStrategoAppl)arg912).getConstructor())
          break Fail389;
        term = Simplify.constStatements0;
        if(true)
          return term;
      }
      context.push("EvalWhile_0_0");
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class $Eval$For_0_0 extends Strategy 
  { 
    public static $Eval$For_0_0 instance = new $Eval$For_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      ITermFactory termFactory = context.getFactory();
      context.push("EvalFor_0_0");
      Fail390:
      { 
        IStrategoTerm term511 = term;
        IStrategoConstructor cons45 = term.getTermType() == IStrategoTerm.APPL ? ((IStrategoAppl)term).getConstructor() : null;
        Success299:
        { 
          if(cons45 == Simplify._consFor_4)
          { 
            Fail391:
            { 
              IStrategoTerm u_84 = null;
              IStrategoTerm v_84 = null;
              IStrategoTerm x_84 = null;
              u_84 = term.getSubterm(0);
              v_84 = term.getSubterm(1);
              if(term.getSubterm(2) != v_84 && !v_84.match(term.getSubterm(2)))
                break Fail391;
              IStrategoTerm arg913 = term.getSubterm(3);
              if(arg913.getTermType() != IStrategoTerm.APPL || Simplify._consStatements_1 != ((IStrategoAppl)arg913).getConstructor())
                break Fail391;
              x_84 = arg913.getSubterm(0);
              term = termFactory.makeAppl(Simplify._consStatements_1, new IStrategoTerm[]{(IStrategoTerm)termFactory.makeListCons(termFactory.makeAppl(Simplify._consAssign_2, new IStrategoTerm[]{u_84, v_84}), termFactory.makeListCons(x_84, (IStrategoList)Simplify.constNil0))});
              if(true)
                break Success299;
            }
            term = term511;
          }
          if(cons45 == Simplify._consFor_4)
          { 
            IStrategoTerm o_84 = null;
            IStrategoTerm p_84 = null;
            IStrategoTerm r_84 = null;
            o_84 = term.getSubterm(0);
            IStrategoTerm arg914 = term.getSubterm(1);
            if(arg914.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg914).getConstructor())
              break Fail390;
            r_84 = arg914.getSubterm(0);
            IStrategoTerm arg915 = term.getSubterm(2);
            if(arg915.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg915).getConstructor())
              break Fail390;
            p_84 = arg915.getSubterm(0);
            term = termFactory.makeTuple(p_84, r_84);
            term = lt$S_0_0.instance.invoke(context, term);
            if(term == null)
              break Fail390;
            term = termFactory.makeAppl(Simplify._consStatements_1, new IStrategoTerm[]{(IStrategoTerm)termFactory.makeListCons(termFactory.makeAppl(Simplify._consAssign_2, new IStrategoTerm[]{o_84, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{r_84})}), (IStrategoList)Simplify.constNil0)});
          }
          else
          { 
            break Fail390;
          }
        }
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class $Eval$C$For_0_0 extends Strategy 
  { 
    public static $Eval$C$For_0_0 instance = new $Eval$C$For_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      ITermFactory termFactory = context.getFactory();
      Fail392:
      { 
        IStrategoTerm b_85 = null;
        if(term.getTermType() != IStrategoTerm.APPL || Simplify._consCFor_4 != ((IStrategoAppl)term).getConstructor())
          break Fail392;
        b_85 = term.getSubterm(0);
        IStrategoTerm arg916 = term.getSubterm(1);
        if(arg916.getTermType() != IStrategoTerm.APPL || Simplify._consFalse_0 != ((IStrategoAppl)arg916).getConstructor())
          break Fail392;
        term = termFactory.makeAppl(Simplify._consStatements_1, new IStrategoTerm[]{(IStrategoTerm)termFactory.makeListCons(termFactory.makeAppl(Simplify._consStatement_1, new IStrategoTerm[]{b_85}), (IStrategoList)Simplify.constNil0)});
        if(true)
          return term;
      }
      context.push("EvalCFor_0_0");
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class $Eval$If$Known$True_0_0 extends Strategy 
  { 
    public static $Eval$If$Known$True_0_0 instance = new $Eval$If$Known$True_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail393:
      { 
        IStrategoTerm term512 = term;
        IStrategoConstructor cons46 = term.getTermType() == IStrategoTerm.APPL ? ((IStrategoAppl)term).getConstructor() : null;
        Success300:
        { 
          if(cons46 == Simplify._consIfKnownStmt_3)
          { 
            Fail394:
            { 
              IStrategoTerm i_85 = null;
              IStrategoTerm arg917 = term.getSubterm(0);
              if(arg917.getTermType() != IStrategoTerm.APPL || Simplify._consTrue_0 != ((IStrategoAppl)arg917).getConstructor())
                break Fail394;
              i_85 = term.getSubterm(1);
              term = i_85;
              if(true)
                break Success300;
            }
            term = term512;
          }
          if(cons46 == Simplify._consIfKnownExp_3)
          { 
            IStrategoTerm e_85 = null;
            IStrategoTerm arg918 = term.getSubterm(0);
            if(arg918.getTermType() != IStrategoTerm.APPL || Simplify._consTrue_0 != ((IStrategoAppl)arg918).getConstructor())
              break Fail393;
            e_85 = term.getSubterm(1);
            term = e_85;
          }
          else
          { 
            break Fail393;
          }
        }
        if(true)
          return term;
      }
      context.push("EvalIfKnownTrue_0_0");
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class $Eval$If$Known$Other_0_0 extends Strategy 
  { 
    public static $Eval$If$Known$Other_0_0 instance = new $Eval$If$Known$Other_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail395:
      { 
        IStrategoTerm term513 = term;
        IStrategoConstructor cons47 = term.getTermType() == IStrategoTerm.APPL ? ((IStrategoAppl)term).getConstructor() : null;
        Success301:
        { 
          if(cons47 == Simplify._consIfKnownStmt_3)
          { 
            Fail396:
            { 
              IStrategoTerm r_85 = null;
              r_85 = term.getSubterm(2);
              term = r_85;
              if(true)
                break Success301;
            }
            term = term513;
          }
          if(cons47 == Simplify._consIfKnownExp_3)
          { 
            IStrategoTerm m_85 = null;
            m_85 = term.getSubterm(2);
            term = m_85;
          }
          else
          { 
            break Fail395;
          }
        }
        if(true)
          return term;
      }
      context.push("EvalIfKnownOther_0_0");
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class main_0_0 extends Strategy 
  { 
    public static main_0_0 instance = new main_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      context.push("main_0_0");
      Fail397:
      { 
        term = io_$Simplify_0_0.instance.invoke(context, term);
        if(term == null)
          break Fail397;
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class $C$For_4_0 extends Strategy 
  { 
    public static $C$For_4_0 instance = new $C$For_4_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term, Strategy z_88, Strategy a_89, Strategy b_89, Strategy e_89)
    { 
      ITermFactory termFactory = context.getFactory();
      context.push("CFor_4_0");
      Fail398:
      { 
        IStrategoTerm r_404 = null;
        IStrategoTerm n_404 = null;
        IStrategoTerm o_404 = null;
        IStrategoTerm p_404 = null;
        IStrategoTerm q_404 = null;
        IStrategoTerm s_404 = null;
        IStrategoTerm t_404 = null;
        IStrategoTerm u_404 = null;
        if(term.getTermType() != IStrategoTerm.APPL || Simplify._consCFor_4 != ((IStrategoAppl)term).getConstructor())
          break Fail398;
        n_404 = term.getSubterm(0);
        o_404 = term.getSubterm(1);
        p_404 = term.getSubterm(2);
        q_404 = term.getSubterm(3);
        IStrategoList annos0 = term.getAnnotations();
        r_404 = annos0;
        term = z_88.invoke(context, n_404);
        if(term == null)
          break Fail398;
        s_404 = term;
        term = a_89.invoke(context, o_404);
        if(term == null)
          break Fail398;
        t_404 = term;
        term = b_89.invoke(context, p_404);
        if(term == null)
          break Fail398;
        u_404 = term;
        term = e_89.invoke(context, q_404);
        if(term == null)
          break Fail398;
        term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consCFor_4, new IStrategoTerm[]{s_404, t_404, u_404, term}), checkListAnnos(termFactory, r_404));
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class $Assert_1_0 extends Strategy 
  { 
    public static $Assert_1_0 instance = new $Assert_1_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term, Strategy v_89)
    { 
      ITermFactory termFactory = context.getFactory();
      context.push("Assert_1_0");
      Fail399:
      { 
        IStrategoTerm z_405 = null;
        IStrategoTerm y_405 = null;
        if(term.getTermType() != IStrategoTerm.APPL || Simplify._consAssert_1 != ((IStrategoAppl)term).getConstructor())
          break Fail399;
        y_405 = term.getSubterm(0);
        IStrategoList annos1 = term.getAnnotations();
        z_405 = annos1;
        term = v_89.invoke(context, y_405);
        if(term == null)
          break Fail399;
        term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consAssert_1, new IStrategoTerm[]{term}), checkListAnnos(termFactory, z_405));
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class $While_2_0 extends Strategy 
  { 
    public static $While_2_0 instance = new $While_2_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term, Strategy w_89, Strategy y_89)
    { 
      ITermFactory termFactory = context.getFactory();
      context.push("While_2_0");
      Fail400:
      { 
        IStrategoTerm d_406 = null;
        IStrategoTerm b_406 = null;
        IStrategoTerm c_406 = null;
        IStrategoTerm e_406 = null;
        if(term.getTermType() != IStrategoTerm.APPL || Simplify._consWhile_2 != ((IStrategoAppl)term).getConstructor())
          break Fail400;
        b_406 = term.getSubterm(0);
        c_406 = term.getSubterm(1);
        IStrategoList annos2 = term.getAnnotations();
        d_406 = annos2;
        term = w_89.invoke(context, b_406);
        if(term == null)
          break Fail400;
        e_406 = term;
        term = y_89.invoke(context, c_406);
        if(term == null)
          break Fail400;
        term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consWhile_2, new IStrategoTerm[]{e_406, term}), checkListAnnos(termFactory, d_406));
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class $For_4_0 extends Strategy 
  { 
    public static $For_4_0 instance = new $For_4_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term, Strategy z_89, Strategy b_90, Strategy c_90, Strategy e_90)
    { 
      ITermFactory termFactory = context.getFactory();
      context.push("For_4_0");
      Fail401:
      { 
        IStrategoTerm k_406 = null;
        IStrategoTerm g_406 = null;
        IStrategoTerm h_406 = null;
        IStrategoTerm i_406 = null;
        IStrategoTerm j_406 = null;
        IStrategoTerm l_406 = null;
        IStrategoTerm m_406 = null;
        IStrategoTerm n_406 = null;
        if(term.getTermType() != IStrategoTerm.APPL || Simplify._consFor_4 != ((IStrategoAppl)term).getConstructor())
          break Fail401;
        g_406 = term.getSubterm(0);
        h_406 = term.getSubterm(1);
        i_406 = term.getSubterm(2);
        j_406 = term.getSubterm(3);
        IStrategoList annos3 = term.getAnnotations();
        k_406 = annos3;
        term = z_89.invoke(context, g_406);
        if(term == null)
          break Fail401;
        l_406 = term;
        term = b_90.invoke(context, h_406);
        if(term == null)
          break Fail401;
        m_406 = term;
        term = c_90.invoke(context, i_406);
        if(term == null)
          break Fail401;
        n_406 = term;
        term = e_90.invoke(context, j_406);
        if(term == null)
          break Fail401;
        term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consFor_4, new IStrategoTerm[]{l_406, m_406, n_406, term}), checkListAnnos(termFactory, k_406));
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class $If$Else_3_0 extends Strategy 
  { 
    public static $If$Else_3_0 instance = new $If$Else_3_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term, Strategy f_90, Strategy h_90, Strategy i_90)
    { 
      ITermFactory termFactory = context.getFactory();
      context.push("IfElse_3_0");
      Fail402:
      { 
        IStrategoTerm s_406 = null;
        IStrategoTerm p_406 = null;
        IStrategoTerm q_406 = null;
        IStrategoTerm r_406 = null;
        IStrategoTerm t_406 = null;
        IStrategoTerm u_406 = null;
        if(term.getTermType() != IStrategoTerm.APPL || Simplify._consIfElse_3 != ((IStrategoAppl)term).getConstructor())
          break Fail402;
        p_406 = term.getSubterm(0);
        q_406 = term.getSubterm(1);
        r_406 = term.getSubterm(2);
        IStrategoList annos4 = term.getAnnotations();
        s_406 = annos4;
        term = f_90.invoke(context, p_406);
        if(term == null)
          break Fail402;
        t_406 = term;
        term = h_90.invoke(context, q_406);
        if(term == null)
          break Fail402;
        u_406 = term;
        term = i_90.invoke(context, r_406);
        if(term == null)
          break Fail402;
        term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consIfElse_3, new IStrategoTerm[]{t_406, u_406, term}), checkListAnnos(termFactory, s_406));
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class $If_2_0 extends Strategy 
  { 
    public static $If_2_0 instance = new $If_2_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term, Strategy k_90, Strategy l_90)
    { 
      ITermFactory termFactory = context.getFactory();
      context.push("If_2_0");
      Fail403:
      { 
        IStrategoTerm y_406 = null;
        IStrategoTerm w_406 = null;
        IStrategoTerm x_406 = null;
        IStrategoTerm z_406 = null;
        if(term.getTermType() != IStrategoTerm.APPL || Simplify._consIf_2 != ((IStrategoAppl)term).getConstructor())
          break Fail403;
        w_406 = term.getSubterm(0);
        x_406 = term.getSubterm(1);
        IStrategoList annos5 = term.getAnnotations();
        y_406 = annos5;
        term = k_90.invoke(context, w_406);
        if(term == null)
          break Fail403;
        z_406 = term;
        term = l_90.invoke(context, x_406);
        if(term == null)
          break Fail403;
        term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consIf_2, new IStrategoTerm[]{z_406, term}), checkListAnnos(termFactory, y_406));
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class $Assign_2_0 extends Strategy 
  { 
    public static $Assign_2_0 instance = new $Assign_2_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term, Strategy n_90, Strategy o_90)
    { 
      ITermFactory termFactory = context.getFactory();
      context.push("Assign_2_0");
      Fail404:
      { 
        IStrategoTerm d_407 = null;
        IStrategoTerm b_407 = null;
        IStrategoTerm c_407 = null;
        IStrategoTerm e_407 = null;
        if(term.getTermType() != IStrategoTerm.APPL || Simplify._consAssign_2 != ((IStrategoAppl)term).getConstructor())
          break Fail404;
        b_407 = term.getSubterm(0);
        c_407 = term.getSubterm(1);
        IStrategoList annos6 = term.getAnnotations();
        d_407 = annos6;
        term = n_90.invoke(context, b_407);
        if(term == null)
          break Fail404;
        e_407 = term;
        term = o_90.invoke(context, c_407);
        if(term == null)
          break Fail404;
        term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consAssign_2, new IStrategoTerm[]{e_407, term}), checkListAnnos(termFactory, d_407));
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class $Procedure_5_0 extends Strategy 
  { 
    public static $Procedure_5_0 instance = new $Procedure_5_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term, Strategy x_91, Strategy y_91, Strategy z_91, Strategy a_92, Strategy b_92)
    { 
      ITermFactory termFactory = context.getFactory();
      context.push("Procedure_5_0");
      Fail405:
      { 
        IStrategoTerm o_409 = null;
        IStrategoTerm j_409 = null;
        IStrategoTerm k_409 = null;
        IStrategoTerm l_409 = null;
        IStrategoTerm m_409 = null;
        IStrategoTerm n_409 = null;
        IStrategoTerm p_409 = null;
        IStrategoTerm q_409 = null;
        IStrategoTerm r_409 = null;
        IStrategoTerm s_409 = null;
        if(term.getTermType() != IStrategoTerm.APPL || Simplify._consProcedure_5 != ((IStrategoAppl)term).getConstructor())
          break Fail405;
        j_409 = term.getSubterm(0);
        k_409 = term.getSubterm(1);
        l_409 = term.getSubterm(2);
        m_409 = term.getSubterm(3);
        n_409 = term.getSubterm(4);
        IStrategoList annos7 = term.getAnnotations();
        o_409 = annos7;
        term = x_91.invoke(context, j_409);
        if(term == null)
          break Fail405;
        p_409 = term;
        term = y_91.invoke(context, k_409);
        if(term == null)
          break Fail405;
        q_409 = term;
        term = z_91.invoke(context, l_409);
        if(term == null)
          break Fail405;
        r_409 = term;
        term = a_92.invoke(context, m_409);
        if(term == null)
          break Fail405;
        s_409 = term;
        term = b_92.invoke(context, n_409);
        if(term == null)
          break Fail405;
        term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consProcedure_5, new IStrategoTerm[]{p_409, q_409, r_409, s_409, term}), checkListAnnos(termFactory, o_409));
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class $Var_1_0 extends Strategy 
  { 
    public static $Var_1_0 instance = new $Var_1_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term, Strategy g_92)
    { 
      ITermFactory termFactory = context.getFactory();
      context.push("Var_1_0");
      Fail406:
      { 
        IStrategoTerm g_410 = null;
        IStrategoTerm f_410 = null;
        if(term.getTermType() != IStrategoTerm.APPL || Simplify._consVar_1 != ((IStrategoAppl)term).getConstructor())
          break Fail406;
        f_410 = term.getSubterm(0);
        IStrategoList annos8 = term.getAnnotations();
        g_410 = annos8;
        term = g_92.invoke(context, f_410);
        if(term == null)
          break Fail406;
        term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consVar_1, new IStrategoTerm[]{term}), checkListAnnos(termFactory, g_410));
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class $C$Assign_2_0 extends Strategy 
  { 
    public static $C$Assign_2_0 instance = new $C$Assign_2_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term, Strategy k_92, Strategy l_92)
    { 
      ITermFactory termFactory = context.getFactory();
      context.push("CAssign_2_0");
      Fail407:
      { 
        IStrategoTerm s_410 = null;
        IStrategoTerm q_410 = null;
        IStrategoTerm r_410 = null;
        IStrategoTerm t_410 = null;
        if(term.getTermType() != IStrategoTerm.APPL || Simplify._consCAssign_2 != ((IStrategoAppl)term).getConstructor())
          break Fail407;
        q_410 = term.getSubterm(0);
        r_410 = term.getSubterm(1);
        IStrategoList annos9 = term.getAnnotations();
        s_410 = annos9;
        term = k_92.invoke(context, q_410);
        if(term == null)
          break Fail407;
        t_410 = term;
        term = l_92.invoke(context, r_410);
        if(term == null)
          break Fail407;
        term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consCAssign_2, new IStrategoTerm[]{t_410, term}), checkListAnnos(termFactory, s_410));
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class $If$Else$Exp_3_0 extends Strategy 
  { 
    public static $If$Else$Exp_3_0 instance = new $If$Else$Exp_3_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term, Strategy m_92, Strategy r_92, Strategy s_92)
    { 
      ITermFactory termFactory = context.getFactory();
      context.push("IfElseExp_3_0");
      Fail408:
      { 
        IStrategoTerm y_410 = null;
        IStrategoTerm v_410 = null;
        IStrategoTerm w_410 = null;
        IStrategoTerm x_410 = null;
        IStrategoTerm z_410 = null;
        IStrategoTerm a_411 = null;
        if(term.getTermType() != IStrategoTerm.APPL || Simplify._consIfElseExp_3 != ((IStrategoAppl)term).getConstructor())
          break Fail408;
        v_410 = term.getSubterm(0);
        w_410 = term.getSubterm(1);
        x_410 = term.getSubterm(2);
        IStrategoList annos10 = term.getAnnotations();
        y_410 = annos10;
        term = m_92.invoke(context, v_410);
        if(term == null)
          break Fail408;
        z_410 = term;
        term = r_92.invoke(context, w_410);
        if(term == null)
          break Fail408;
        a_411 = term;
        term = s_92.invoke(context, x_410);
        if(term == null)
          break Fail408;
        term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consIfElseExp_3, new IStrategoTerm[]{z_410, a_411, term}), checkListAnnos(termFactory, y_410));
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class $If$Known$Exp_3_0 extends Strategy 
  { 
    public static $If$Known$Exp_3_0 instance = new $If$Known$Exp_3_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term, Strategy u_92, Strategy w_92, Strategy x_92)
    { 
      ITermFactory termFactory = context.getFactory();
      context.push("IfKnownExp_3_0");
      Fail409:
      { 
        IStrategoTerm i_411 = null;
        IStrategoTerm f_411 = null;
        IStrategoTerm g_411 = null;
        IStrategoTerm h_411 = null;
        IStrategoTerm j_411 = null;
        IStrategoTerm k_411 = null;
        if(term.getTermType() != IStrategoTerm.APPL || Simplify._consIfKnownExp_3 != ((IStrategoAppl)term).getConstructor())
          break Fail409;
        f_411 = term.getSubterm(0);
        g_411 = term.getSubterm(1);
        h_411 = term.getSubterm(2);
        IStrategoList annos11 = term.getAnnotations();
        i_411 = annos11;
        term = u_92.invoke(context, f_411);
        if(term == null)
          break Fail409;
        j_411 = term;
        term = w_92.invoke(context, g_411);
        if(term == null)
          break Fail409;
        k_411 = term;
        term = x_92.invoke(context, h_411);
        if(term == null)
          break Fail409;
        term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consIfKnownExp_3, new IStrategoTerm[]{j_411, k_411, term}), checkListAnnos(termFactory, i_411));
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class $And_2_0 extends Strategy 
  { 
    public static $And_2_0 instance = new $And_2_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term, Strategy i_93, Strategy j_93)
    { 
      ITermFactory termFactory = context.getFactory();
      context.push("And_2_0");
      Fail410:
      { 
        IStrategoTerm f_412 = null;
        IStrategoTerm d_412 = null;
        IStrategoTerm e_412 = null;
        IStrategoTerm g_412 = null;
        if(term.getTermType() != IStrategoTerm.APPL || Simplify._consAnd_2 != ((IStrategoAppl)term).getConstructor())
          break Fail410;
        d_412 = term.getSubterm(0);
        e_412 = term.getSubterm(1);
        IStrategoList annos12 = term.getAnnotations();
        f_412 = annos12;
        term = i_93.invoke(context, d_412);
        if(term == null)
          break Fail410;
        g_412 = term;
        term = j_93.invoke(context, e_412);
        if(term == null)
          break Fail410;
        term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consAnd_2, new IStrategoTerm[]{g_412, term}), checkListAnnos(termFactory, f_412));
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class $Neq_2_0 extends Strategy 
  { 
    public static $Neq_2_0 instance = new $Neq_2_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term, Strategy p_93, Strategy q_93)
    { 
      ITermFactory termFactory = context.getFactory();
      context.push("Neq_2_0");
      Fail411:
      { 
        IStrategoTerm u_412 = null;
        IStrategoTerm s_412 = null;
        IStrategoTerm t_412 = null;
        IStrategoTerm v_412 = null;
        if(term.getTermType() != IStrategoTerm.APPL || Simplify._consNeq_2 != ((IStrategoAppl)term).getConstructor())
          break Fail411;
        s_412 = term.getSubterm(0);
        t_412 = term.getSubterm(1);
        IStrategoList annos13 = term.getAnnotations();
        u_412 = annos13;
        term = p_93.invoke(context, s_412);
        if(term == null)
          break Fail411;
        v_412 = term;
        term = q_93.invoke(context, t_412);
        if(term == null)
          break Fail411;
        term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consNeq_2, new IStrategoTerm[]{v_412, term}), checkListAnnos(termFactory, u_412));
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class $Equ_2_0 extends Strategy 
  { 
    public static $Equ_2_0 instance = new $Equ_2_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term, Strategy r_93, Strategy s_93)
    { 
      ITermFactory termFactory = context.getFactory();
      context.push("Equ_2_0");
      Fail412:
      { 
        IStrategoTerm z_412 = null;
        IStrategoTerm x_412 = null;
        IStrategoTerm y_412 = null;
        IStrategoTerm a_413 = null;
        if(term.getTermType() != IStrategoTerm.APPL || Simplify._consEqu_2 != ((IStrategoAppl)term).getConstructor())
          break Fail412;
        x_412 = term.getSubterm(0);
        y_412 = term.getSubterm(1);
        IStrategoList annos14 = term.getAnnotations();
        z_412 = annos14;
        term = r_93.invoke(context, x_412);
        if(term == null)
          break Fail412;
        a_413 = term;
        term = s_93.invoke(context, y_412);
        if(term == null)
          break Fail412;
        term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consEqu_2, new IStrategoTerm[]{a_413, term}), checkListAnnos(termFactory, z_412));
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class $Leq_2_0 extends Strategy 
  { 
    public static $Leq_2_0 instance = new $Leq_2_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term, Strategy w_93, Strategy x_93)
    { 
      ITermFactory termFactory = context.getFactory();
      context.push("Leq_2_0");
      Fail413:
      { 
        IStrategoTerm j_413 = null;
        IStrategoTerm h_413 = null;
        IStrategoTerm i_413 = null;
        IStrategoTerm k_413 = null;
        if(term.getTermType() != IStrategoTerm.APPL || Simplify._consLeq_2 != ((IStrategoAppl)term).getConstructor())
          break Fail413;
        h_413 = term.getSubterm(0);
        i_413 = term.getSubterm(1);
        IStrategoList annos15 = term.getAnnotations();
        j_413 = annos15;
        term = w_93.invoke(context, h_413);
        if(term == null)
          break Fail413;
        k_413 = term;
        term = x_93.invoke(context, i_413);
        if(term == null)
          break Fail413;
        term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consLeq_2, new IStrategoTerm[]{k_413, term}), checkListAnnos(termFactory, j_413));
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class $Gt_2_0 extends Strategy 
  { 
    public static $Gt_2_0 instance = new $Gt_2_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term, Strategy y_93, Strategy z_93)
    { 
      ITermFactory termFactory = context.getFactory();
      context.push("Gt_2_0");
      Fail414:
      { 
        IStrategoTerm o_413 = null;
        IStrategoTerm m_413 = null;
        IStrategoTerm n_413 = null;
        IStrategoTerm p_413 = null;
        if(term.getTermType() != IStrategoTerm.APPL || Simplify._consGt_2 != ((IStrategoAppl)term).getConstructor())
          break Fail414;
        m_413 = term.getSubterm(0);
        n_413 = term.getSubterm(1);
        IStrategoList annos16 = term.getAnnotations();
        o_413 = annos16;
        term = y_93.invoke(context, m_413);
        if(term == null)
          break Fail414;
        p_413 = term;
        term = z_93.invoke(context, n_413);
        if(term == null)
          break Fail414;
        term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consGt_2, new IStrategoTerm[]{p_413, term}), checkListAnnos(termFactory, o_413));
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class $Lt_2_0 extends Strategy 
  { 
    public static $Lt_2_0 instance = new $Lt_2_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term, Strategy a_94, Strategy b_94)
    { 
      ITermFactory termFactory = context.getFactory();
      context.push("Lt_2_0");
      Fail415:
      { 
        IStrategoTerm t_413 = null;
        IStrategoTerm r_413 = null;
        IStrategoTerm s_413 = null;
        IStrategoTerm u_413 = null;
        if(term.getTermType() != IStrategoTerm.APPL || Simplify._consLt_2 != ((IStrategoAppl)term).getConstructor())
          break Fail415;
        r_413 = term.getSubterm(0);
        s_413 = term.getSubterm(1);
        IStrategoList annos17 = term.getAnnotations();
        t_413 = annos17;
        term = a_94.invoke(context, r_413);
        if(term == null)
          break Fail415;
        u_413 = term;
        term = b_94.invoke(context, s_413);
        if(term == null)
          break Fail415;
        term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consLt_2, new IStrategoTerm[]{u_413, term}), checkListAnnos(termFactory, t_413));
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class $Int_1_0 extends Strategy 
  { 
    public static $Int_1_0 instance = new $Int_1_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term, Strategy o_94)
    { 
      ITermFactory termFactory = context.getFactory();
      context.push("Int_1_0");
      Fail416:
      { 
        IStrategoTerm c_415 = null;
        IStrategoTerm b_415 = null;
        if(term.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)term).getConstructor())
          break Fail416;
        b_415 = term.getSubterm(0);
        IStrategoList annos18 = term.getAnnotations();
        c_415 = annos18;
        term = o_94.invoke(context, b_415);
        if(term == null)
          break Fail416;
        term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{term}), checkListAnnos(termFactory, c_415));
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class $Assertion7_0_0 extends Strategy 
  { 
    public static $Assertion7_0_0 instance = new $Assertion7_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      context.push("Assertion7_0_0");
      Fail417:
      { 
        TermReference a_99 = new TermReference();
        TermReference b_99 = new TermReference();
        IStrategoTerm f_99 = null;
        if(b_99.value == null)
          b_99.value = term;
        else
          if(b_99.value != term && !b_99.value.match(term))
            break Fail417;
        if(a_99.value == null)
          a_99.value = term;
        else
          if(a_99.value != term && !a_99.value.match(term))
            break Fail417;
        f_99 = term;
        term = dr_lookup_rule_0_2.instance.invoke(context, f_99, Simplify.const61, b_99.value);
        if(term == null)
          break Fail417;
        lifted247 lifted2470 = new lifted247();
        lifted2470.a_99 = a_99;
        lifted2470.b_99 = b_99;
        term = fetch_elem_1_0.instance.invoke(context, term, lifted2470);
        if(term == null)
          break Fail417;
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class $Assertion6_0_0 extends Strategy 
  { 
    public static $Assertion6_0_0 instance = new $Assertion6_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      ITermFactory termFactory = context.getFactory();
      context.push("Assertion6_0_0");
      Fail418:
      { 
        IStrategoTerm term514 = term;
        Success302:
        { 
          Fail419:
          { 
            TermReference i_109 = new TermReference();
            TermReference k_109 = new TermReference();
            TermReference l_109 = new TermReference();
            IStrategoTerm q_109 = null;
            IStrategoTerm s_109 = null;
            IStrategoTerm t_109 = null;
            if(k_109.value == null)
              k_109.value = term;
            else
              if(k_109.value != term && !k_109.value.match(term))
                break Fail419;
            if(term.getTermType() != IStrategoTerm.APPL || Simplify._consEqu_2 != ((IStrategoAppl)term).getConstructor())
              break Fail419;
            if(l_109.value == null)
              l_109.value = term.getSubterm(0);
            else
              if(l_109.value != term.getSubterm(0) && !l_109.value.match(term.getSubterm(0)))
                break Fail419;
            IStrategoTerm arg919 = term.getSubterm(1);
            if(arg919.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg919).getConstructor())
              break Fail419;
            if(i_109.value == null)
              i_109.value = arg919.getSubterm(0);
            else
              if(i_109.value != arg919.getSubterm(0) && !i_109.value.match(arg919.getSubterm(0)))
                break Fail419;
            s_109 = term;
            q_109 = Simplify.const60;
            term = s_109;
            t_109 = s_109;
            if(l_109.value == null)
              break Fail419;
            term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consEqu_2, new IStrategoTerm[]{l_109.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
            term = dr_lookup_rule_0_2.instance.invoke(context, t_109, q_109, term);
            if(term == null)
              break Fail419;
            lifted248 lifted2480 = new lifted248();
            lifted2480.l_109 = l_109;
            lifted2480.i_109 = i_109;
            lifted2480.k_109 = k_109;
            term = fetch_elem_1_0.instance.invoke(context, term, lifted2480);
            if(term == null)
              break Fail419;
            if(true)
              break Success302;
          }
          term = term514;
          IStrategoTerm term515 = term;
          Success303:
          { 
            Fail420:
            { 
              TermReference z_108 = new TermReference();
              TermReference a_109 = new TermReference();
              TermReference b_109 = new TermReference();
              IStrategoTerm e_109 = null;
              IStrategoTerm g_109 = null;
              IStrategoTerm h_109 = null;
              if(a_109.value == null)
                a_109.value = term;
              else
                if(a_109.value != term && !a_109.value.match(term))
                  break Fail420;
              if(term.getTermType() != IStrategoTerm.APPL || Simplify._consGeq_2 != ((IStrategoAppl)term).getConstructor())
                break Fail420;
              if(b_109.value == null)
                b_109.value = term.getSubterm(0);
              else
                if(b_109.value != term.getSubterm(0) && !b_109.value.match(term.getSubterm(0)))
                  break Fail420;
              IStrategoTerm arg920 = term.getSubterm(1);
              if(arg920.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg920).getConstructor())
                break Fail420;
              if(z_108.value == null)
                z_108.value = arg920.getSubterm(0);
              else
                if(z_108.value != arg920.getSubterm(0) && !z_108.value.match(arg920.getSubterm(0)))
                  break Fail420;
              g_109 = term;
              e_109 = Simplify.const60;
              term = g_109;
              h_109 = g_109;
              if(b_109.value == null)
                break Fail420;
              term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consGeq_2, new IStrategoTerm[]{b_109.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
              term = dr_lookup_rule_0_2.instance.invoke(context, h_109, e_109, term);
              if(term == null)
                break Fail420;
              lifted249 lifted2490 = new lifted249();
              lifted2490.b_109 = b_109;
              lifted2490.z_108 = z_108;
              lifted2490.a_109 = a_109;
              term = fetch_elem_1_0.instance.invoke(context, term, lifted2490);
              if(term == null)
                break Fail420;
              if(true)
                break Success303;
            }
            term = term515;
            IStrategoTerm term516 = term;
            Success304:
            { 
              Fail421:
              { 
                TermReference q_108 = new TermReference();
                TermReference r_108 = new TermReference();
                TermReference s_108 = new TermReference();
                IStrategoTerm v_108 = null;
                IStrategoTerm x_108 = null;
                IStrategoTerm y_108 = null;
                if(r_108.value == null)
                  r_108.value = term;
                else
                  if(r_108.value != term && !r_108.value.match(term))
                    break Fail421;
                if(term.getTermType() != IStrategoTerm.APPL || Simplify._consGt_2 != ((IStrategoAppl)term).getConstructor())
                  break Fail421;
                if(s_108.value == null)
                  s_108.value = term.getSubterm(0);
                else
                  if(s_108.value != term.getSubterm(0) && !s_108.value.match(term.getSubterm(0)))
                    break Fail421;
                IStrategoTerm arg921 = term.getSubterm(1);
                if(arg921.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg921).getConstructor())
                  break Fail421;
                if(q_108.value == null)
                  q_108.value = arg921.getSubterm(0);
                else
                  if(q_108.value != arg921.getSubterm(0) && !q_108.value.match(arg921.getSubterm(0)))
                    break Fail421;
                x_108 = term;
                v_108 = Simplify.const60;
                term = x_108;
                y_108 = x_108;
                if(s_108.value == null)
                  break Fail421;
                term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consGt_2, new IStrategoTerm[]{s_108.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
                term = dr_lookup_rule_0_2.instance.invoke(context, y_108, v_108, term);
                if(term == null)
                  break Fail421;
                lifted250 lifted2500 = new lifted250();
                lifted2500.s_108 = s_108;
                lifted2500.q_108 = q_108;
                lifted2500.r_108 = r_108;
                term = fetch_elem_1_0.instance.invoke(context, term, lifted2500);
                if(term == null)
                  break Fail421;
                if(true)
                  break Success304;
              }
              term = term516;
              IStrategoTerm term517 = term;
              Success305:
              { 
                Fail422:
                { 
                  TermReference h_108 = new TermReference();
                  TermReference i_108 = new TermReference();
                  TermReference j_108 = new TermReference();
                  IStrategoTerm m_108 = null;
                  IStrategoTerm o_108 = null;
                  IStrategoTerm p_108 = null;
                  if(i_108.value == null)
                    i_108.value = term;
                  else
                    if(i_108.value != term && !i_108.value.match(term))
                      break Fail422;
                  if(term.getTermType() != IStrategoTerm.APPL || Simplify._consNeq_2 != ((IStrategoAppl)term).getConstructor())
                    break Fail422;
                  if(j_108.value == null)
                    j_108.value = term.getSubterm(0);
                  else
                    if(j_108.value != term.getSubterm(0) && !j_108.value.match(term.getSubterm(0)))
                      break Fail422;
                  IStrategoTerm arg922 = term.getSubterm(1);
                  if(arg922.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg922).getConstructor())
                    break Fail422;
                  if(h_108.value == null)
                    h_108.value = arg922.getSubterm(0);
                  else
                    if(h_108.value != arg922.getSubterm(0) && !h_108.value.match(arg922.getSubterm(0)))
                      break Fail422;
                  o_108 = term;
                  m_108 = Simplify.const60;
                  term = o_108;
                  p_108 = o_108;
                  if(j_108.value == null)
                    break Fail422;
                  term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consNeq_2, new IStrategoTerm[]{j_108.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
                  term = dr_lookup_rule_0_2.instance.invoke(context, p_108, m_108, term);
                  if(term == null)
                    break Fail422;
                  lifted251 lifted2510 = new lifted251();
                  lifted2510.j_108 = j_108;
                  lifted2510.h_108 = h_108;
                  lifted2510.i_108 = i_108;
                  term = fetch_elem_1_0.instance.invoke(context, term, lifted2510);
                  if(term == null)
                    break Fail422;
                  if(true)
                    break Success305;
                }
                term = term517;
                IStrategoTerm term518 = term;
                Success306:
                { 
                  Fail423:
                  { 
                    TermReference y_107 = new TermReference();
                    TermReference z_107 = new TermReference();
                    TermReference a_108 = new TermReference();
                    IStrategoTerm d_108 = null;
                    IStrategoTerm f_108 = null;
                    IStrategoTerm g_108 = null;
                    if(z_107.value == null)
                      z_107.value = term;
                    else
                      if(z_107.value != term && !z_107.value.match(term))
                        break Fail423;
                    if(term.getTermType() != IStrategoTerm.APPL || Simplify._consLeq_2 != ((IStrategoAppl)term).getConstructor())
                      break Fail423;
                    if(a_108.value == null)
                      a_108.value = term.getSubterm(0);
                    else
                      if(a_108.value != term.getSubterm(0) && !a_108.value.match(term.getSubterm(0)))
                        break Fail423;
                    IStrategoTerm arg923 = term.getSubterm(1);
                    if(arg923.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg923).getConstructor())
                      break Fail423;
                    if(y_107.value == null)
                      y_107.value = arg923.getSubterm(0);
                    else
                      if(y_107.value != arg923.getSubterm(0) && !y_107.value.match(arg923.getSubterm(0)))
                        break Fail423;
                    f_108 = term;
                    d_108 = Simplify.const60;
                    term = f_108;
                    g_108 = f_108;
                    if(a_108.value == null)
                      break Fail423;
                    term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consLeq_2, new IStrategoTerm[]{a_108.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
                    term = dr_lookup_rule_0_2.instance.invoke(context, g_108, d_108, term);
                    if(term == null)
                      break Fail423;
                    lifted252 lifted2520 = new lifted252();
                    lifted2520.a_108 = a_108;
                    lifted2520.y_107 = y_107;
                    lifted2520.z_107 = z_107;
                    term = fetch_elem_1_0.instance.invoke(context, term, lifted2520);
                    if(term == null)
                      break Fail423;
                    if(true)
                      break Success306;
                  }
                  term = term518;
                  TermReference p_107 = new TermReference();
                  TermReference q_107 = new TermReference();
                  TermReference r_107 = new TermReference();
                  IStrategoTerm u_107 = null;
                  IStrategoTerm w_107 = null;
                  IStrategoTerm x_107 = null;
                  if(q_107.value == null)
                    q_107.value = term;
                  else
                    if(q_107.value != term && !q_107.value.match(term))
                      break Fail418;
                  if(term.getTermType() != IStrategoTerm.APPL || Simplify._consLt_2 != ((IStrategoAppl)term).getConstructor())
                    break Fail418;
                  if(r_107.value == null)
                    r_107.value = term.getSubterm(0);
                  else
                    if(r_107.value != term.getSubterm(0) && !r_107.value.match(term.getSubterm(0)))
                      break Fail418;
                  IStrategoTerm arg924 = term.getSubterm(1);
                  if(arg924.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg924).getConstructor())
                    break Fail418;
                  if(p_107.value == null)
                    p_107.value = arg924.getSubterm(0);
                  else
                    if(p_107.value != arg924.getSubterm(0) && !p_107.value.match(arg924.getSubterm(0)))
                      break Fail418;
                  w_107 = term;
                  u_107 = Simplify.const60;
                  term = w_107;
                  x_107 = w_107;
                  if(r_107.value == null)
                    break Fail418;
                  term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consLt_2, new IStrategoTerm[]{r_107.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
                  term = dr_lookup_rule_0_2.instance.invoke(context, x_107, u_107, term);
                  if(term == null)
                    break Fail418;
                  lifted253 lifted2530 = new lifted253();
                  lifted2530.r_107 = r_107;
                  lifted2530.p_107 = p_107;
                  lifted2530.q_107 = q_107;
                  term = fetch_elem_1_0.instance.invoke(context, term, lifted2530);
                  if(term == null)
                    break Fail418;
                }
              }
            }
          }
        }
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class $Assertion5_0_0 extends Strategy 
  { 
    public static $Assertion5_0_0 instance = new $Assertion5_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      ITermFactory termFactory = context.getFactory();
      context.push("Assertion5_0_0");
      Fail424:
      { 
        IStrategoTerm term519 = term;
        Success307:
        { 
          Fail425:
          { 
            TermReference q_113 = new TermReference();
            TermReference r_113 = new TermReference();
            TermReference s_113 = new TermReference();
            IStrategoTerm v_113 = null;
            IStrategoTerm x_113 = null;
            IStrategoTerm y_113 = null;
            if(r_113.value == null)
              r_113.value = term;
            else
              if(r_113.value != term && !r_113.value.match(term))
                break Fail425;
            if(term.getTermType() != IStrategoTerm.APPL || Simplify._consEqu_2 != ((IStrategoAppl)term).getConstructor())
              break Fail425;
            if(s_113.value == null)
              s_113.value = term.getSubterm(0);
            else
              if(s_113.value != term.getSubterm(0) && !s_113.value.match(term.getSubterm(0)))
                break Fail425;
            IStrategoTerm arg925 = term.getSubterm(1);
            if(arg925.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg925).getConstructor())
              break Fail425;
            if(q_113.value == null)
              q_113.value = arg925.getSubterm(0);
            else
              if(q_113.value != arg925.getSubterm(0) && !q_113.value.match(arg925.getSubterm(0)))
                break Fail425;
            x_113 = term;
            v_113 = Simplify.const59;
            term = x_113;
            y_113 = x_113;
            if(s_113.value == null)
              break Fail425;
            term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consEqu_2, new IStrategoTerm[]{s_113.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
            term = dr_lookup_rule_0_2.instance.invoke(context, y_113, v_113, term);
            if(term == null)
              break Fail425;
            lifted254 lifted2540 = new lifted254();
            lifted2540.s_113 = s_113;
            lifted2540.q_113 = q_113;
            lifted2540.r_113 = r_113;
            term = fetch_elem_1_0.instance.invoke(context, term, lifted2540);
            if(term == null)
              break Fail425;
            if(true)
              break Success307;
          }
          term = term519;
          TermReference f_113 = new TermReference();
          TermReference h_113 = new TermReference();
          TermReference i_113 = new TermReference();
          IStrategoTerm l_113 = null;
          IStrategoTerm n_113 = null;
          IStrategoTerm p_113 = null;
          if(h_113.value == null)
            h_113.value = term;
          else
            if(h_113.value != term && !h_113.value.match(term))
              break Fail424;
          if(term.getTermType() != IStrategoTerm.APPL || Simplify._consNeq_2 != ((IStrategoAppl)term).getConstructor())
            break Fail424;
          if(i_113.value == null)
            i_113.value = term.getSubterm(0);
          else
            if(i_113.value != term.getSubterm(0) && !i_113.value.match(term.getSubterm(0)))
              break Fail424;
          IStrategoTerm arg926 = term.getSubterm(1);
          if(arg926.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg926).getConstructor())
            break Fail424;
          if(f_113.value == null)
            f_113.value = arg926.getSubterm(0);
          else
            if(f_113.value != arg926.getSubterm(0) && !f_113.value.match(arg926.getSubterm(0)))
              break Fail424;
          n_113 = term;
          l_113 = Simplify.const59;
          term = n_113;
          p_113 = n_113;
          if(i_113.value == null)
            break Fail424;
          term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consNeq_2, new IStrategoTerm[]{i_113.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
          term = dr_lookup_rule_0_2.instance.invoke(context, p_113, l_113, term);
          if(term == null)
            break Fail424;
          lifted255 lifted2550 = new lifted255();
          lifted2550.i_113 = i_113;
          lifted2550.f_113 = f_113;
          lifted2550.h_113 = h_113;
          term = fetch_elem_1_0.instance.invoke(context, term, lifted2550);
          if(term == null)
            break Fail424;
        }
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class $Assertion4_0_0 extends Strategy 
  { 
    public static $Assertion4_0_0 instance = new $Assertion4_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      ITermFactory termFactory = context.getFactory();
      context.push("Assertion4_0_0");
      Fail426:
      { 
        IStrategoTerm term520 = term;
        Success308:
        { 
          Fail427:
          { 
            TermReference u_124 = new TermReference();
            TermReference v_124 = new TermReference();
            TermReference w_124 = new TermReference();
            IStrategoTerm b_125 = null;
            IStrategoTerm d_125 = null;
            IStrategoTerm e_125 = null;
            if(v_124.value == null)
              v_124.value = term;
            else
              if(v_124.value != term && !v_124.value.match(term))
                break Fail427;
            if(term.getTermType() != IStrategoTerm.APPL || Simplify._consEqu_2 != ((IStrategoAppl)term).getConstructor())
              break Fail427;
            if(w_124.value == null)
              w_124.value = term.getSubterm(0);
            else
              if(w_124.value != term.getSubterm(0) && !w_124.value.match(term.getSubterm(0)))
                break Fail427;
            IStrategoTerm arg927 = term.getSubterm(1);
            if(arg927.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg927).getConstructor())
              break Fail427;
            if(u_124.value == null)
              u_124.value = arg927.getSubterm(0);
            else
              if(u_124.value != arg927.getSubterm(0) && !u_124.value.match(arg927.getSubterm(0)))
                break Fail427;
            d_125 = term;
            b_125 = Simplify.const58;
            term = d_125;
            e_125 = d_125;
            if(w_124.value == null)
              break Fail427;
            term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consEqu_2, new IStrategoTerm[]{w_124.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
            term = dr_lookup_rule_0_2.instance.invoke(context, e_125, b_125, term);
            if(term == null)
              break Fail427;
            lifted256 lifted2560 = new lifted256();
            lifted2560.w_124 = w_124;
            lifted2560.u_124 = u_124;
            lifted2560.v_124 = v_124;
            term = fetch_elem_1_0.instance.invoke(context, term, lifted2560);
            if(term == null)
              break Fail427;
            if(true)
              break Success308;
          }
          term = term520;
          IStrategoTerm term521 = term;
          Success309:
          { 
            Fail428:
            { 
              TermReference f_124 = new TermReference();
              TermReference i_124 = new TermReference();
              TermReference m_124 = new TermReference();
              IStrategoTerm p_124 = null;
              IStrategoTerm s_124 = null;
              IStrategoTerm t_124 = null;
              if(i_124.value == null)
                i_124.value = term;
              else
                if(i_124.value != term && !i_124.value.match(term))
                  break Fail428;
              if(term.getTermType() != IStrategoTerm.APPL || Simplify._consLeq_2 != ((IStrategoAppl)term).getConstructor())
                break Fail428;
              if(m_124.value == null)
                m_124.value = term.getSubterm(0);
              else
                if(m_124.value != term.getSubterm(0) && !m_124.value.match(term.getSubterm(0)))
                  break Fail428;
              IStrategoTerm arg928 = term.getSubterm(1);
              if(arg928.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg928).getConstructor())
                break Fail428;
              if(f_124.value == null)
                f_124.value = arg928.getSubterm(0);
              else
                if(f_124.value != arg928.getSubterm(0) && !f_124.value.match(arg928.getSubterm(0)))
                  break Fail428;
              s_124 = term;
              p_124 = Simplify.const58;
              term = s_124;
              t_124 = s_124;
              if(m_124.value == null)
                break Fail428;
              term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consLeq_2, new IStrategoTerm[]{m_124.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
              term = dr_lookup_rule_0_2.instance.invoke(context, t_124, p_124, term);
              if(term == null)
                break Fail428;
              lifted257 lifted2570 = new lifted257();
              lifted2570.m_124 = m_124;
              lifted2570.f_124 = f_124;
              lifted2570.i_124 = i_124;
              term = fetch_elem_1_0.instance.invoke(context, term, lifted2570);
              if(term == null)
                break Fail428;
              if(true)
                break Success309;
            }
            term = term521;
            IStrategoTerm term522 = term;
            Success310:
            { 
              Fail429:
              { 
                TermReference u_123 = new TermReference();
                TermReference v_123 = new TermReference();
                TermReference w_123 = new TermReference();
                IStrategoTerm a_124 = null;
                IStrategoTerm c_124 = null;
                IStrategoTerm d_124 = null;
                if(v_123.value == null)
                  v_123.value = term;
                else
                  if(v_123.value != term && !v_123.value.match(term))
                    break Fail429;
                if(term.getTermType() != IStrategoTerm.APPL || Simplify._consLt_2 != ((IStrategoAppl)term).getConstructor())
                  break Fail429;
                if(w_123.value == null)
                  w_123.value = term.getSubterm(0);
                else
                  if(w_123.value != term.getSubterm(0) && !w_123.value.match(term.getSubterm(0)))
                    break Fail429;
                IStrategoTerm arg929 = term.getSubterm(1);
                if(arg929.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg929).getConstructor())
                  break Fail429;
                if(u_123.value == null)
                  u_123.value = arg929.getSubterm(0);
                else
                  if(u_123.value != arg929.getSubterm(0) && !u_123.value.match(arg929.getSubterm(0)))
                    break Fail429;
                c_124 = term;
                a_124 = Simplify.const58;
                term = c_124;
                d_124 = c_124;
                if(w_123.value == null)
                  break Fail429;
                term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consLt_2, new IStrategoTerm[]{w_123.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
                term = dr_lookup_rule_0_2.instance.invoke(context, d_124, a_124, term);
                if(term == null)
                  break Fail429;
                lifted258 lifted2580 = new lifted258();
                lifted2580.w_123 = w_123;
                lifted2580.u_123 = u_123;
                lifted2580.v_123 = v_123;
                term = fetch_elem_1_0.instance.invoke(context, term, lifted2580);
                if(term == null)
                  break Fail429;
                if(true)
                  break Success310;
              }
              term = term522;
              IStrategoTerm term523 = term;
              Success311:
              { 
                Fail430:
                { 
                  TermReference l_123 = new TermReference();
                  TermReference m_123 = new TermReference();
                  TermReference n_123 = new TermReference();
                  IStrategoTerm q_123 = null;
                  IStrategoTerm s_123 = null;
                  IStrategoTerm t_123 = null;
                  if(m_123.value == null)
                    m_123.value = term;
                  else
                    if(m_123.value != term && !m_123.value.match(term))
                      break Fail430;
                  if(term.getTermType() != IStrategoTerm.APPL || Simplify._consNeq_2 != ((IStrategoAppl)term).getConstructor())
                    break Fail430;
                  if(n_123.value == null)
                    n_123.value = term.getSubterm(0);
                  else
                    if(n_123.value != term.getSubterm(0) && !n_123.value.match(term.getSubterm(0)))
                      break Fail430;
                  IStrategoTerm arg930 = term.getSubterm(1);
                  if(arg930.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg930).getConstructor())
                    break Fail430;
                  if(l_123.value == null)
                    l_123.value = arg930.getSubterm(0);
                  else
                    if(l_123.value != arg930.getSubterm(0) && !l_123.value.match(arg930.getSubterm(0)))
                      break Fail430;
                  s_123 = term;
                  q_123 = Simplify.const58;
                  term = s_123;
                  t_123 = s_123;
                  if(n_123.value == null)
                    break Fail430;
                  term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consNeq_2, new IStrategoTerm[]{n_123.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
                  term = dr_lookup_rule_0_2.instance.invoke(context, t_123, q_123, term);
                  if(term == null)
                    break Fail430;
                  lifted259 lifted2590 = new lifted259();
                  lifted2590.n_123 = n_123;
                  lifted2590.l_123 = l_123;
                  lifted2590.m_123 = m_123;
                  term = fetch_elem_1_0.instance.invoke(context, term, lifted2590);
                  if(term == null)
                    break Fail430;
                  if(true)
                    break Success311;
                }
                term = term523;
                IStrategoTerm term524 = term;
                Success312:
                { 
                  Fail431:
                  { 
                    TermReference c_123 = new TermReference();
                    TermReference d_123 = new TermReference();
                    TermReference e_123 = new TermReference();
                    IStrategoTerm h_123 = null;
                    IStrategoTerm j_123 = null;
                    IStrategoTerm k_123 = null;
                    if(d_123.value == null)
                      d_123.value = term;
                    else
                      if(d_123.value != term && !d_123.value.match(term))
                        break Fail431;
                    if(term.getTermType() != IStrategoTerm.APPL || Simplify._consGeq_2 != ((IStrategoAppl)term).getConstructor())
                      break Fail431;
                    if(e_123.value == null)
                      e_123.value = term.getSubterm(0);
                    else
                      if(e_123.value != term.getSubterm(0) && !e_123.value.match(term.getSubterm(0)))
                        break Fail431;
                    IStrategoTerm arg931 = term.getSubterm(1);
                    if(arg931.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg931).getConstructor())
                      break Fail431;
                    if(c_123.value == null)
                      c_123.value = arg931.getSubterm(0);
                    else
                      if(c_123.value != arg931.getSubterm(0) && !c_123.value.match(arg931.getSubterm(0)))
                        break Fail431;
                    j_123 = term;
                    h_123 = Simplify.const58;
                    term = j_123;
                    k_123 = j_123;
                    if(e_123.value == null)
                      break Fail431;
                    term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consGeq_2, new IStrategoTerm[]{e_123.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
                    term = dr_lookup_rule_0_2.instance.invoke(context, k_123, h_123, term);
                    if(term == null)
                      break Fail431;
                    lifted260 lifted2600 = new lifted260();
                    lifted2600.e_123 = e_123;
                    lifted2600.c_123 = c_123;
                    lifted2600.d_123 = d_123;
                    term = fetch_elem_1_0.instance.invoke(context, term, lifted2600);
                    if(term == null)
                      break Fail431;
                    if(true)
                      break Success312;
                  }
                  term = term524;
                  TermReference t_122 = new TermReference();
                  TermReference u_122 = new TermReference();
                  TermReference v_122 = new TermReference();
                  IStrategoTerm y_122 = null;
                  IStrategoTerm a_123 = null;
                  IStrategoTerm b_123 = null;
                  if(u_122.value == null)
                    u_122.value = term;
                  else
                    if(u_122.value != term && !u_122.value.match(term))
                      break Fail426;
                  if(term.getTermType() != IStrategoTerm.APPL || Simplify._consGt_2 != ((IStrategoAppl)term).getConstructor())
                    break Fail426;
                  if(v_122.value == null)
                    v_122.value = term.getSubterm(0);
                  else
                    if(v_122.value != term.getSubterm(0) && !v_122.value.match(term.getSubterm(0)))
                      break Fail426;
                  IStrategoTerm arg932 = term.getSubterm(1);
                  if(arg932.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg932).getConstructor())
                    break Fail426;
                  if(t_122.value == null)
                    t_122.value = arg932.getSubterm(0);
                  else
                    if(t_122.value != arg932.getSubterm(0) && !t_122.value.match(arg932.getSubterm(0)))
                      break Fail426;
                  a_123 = term;
                  y_122 = Simplify.const58;
                  term = a_123;
                  b_123 = a_123;
                  if(v_122.value == null)
                    break Fail426;
                  term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consGt_2, new IStrategoTerm[]{v_122.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
                  term = dr_lookup_rule_0_2.instance.invoke(context, b_123, y_122, term);
                  if(term == null)
                    break Fail426;
                  lifted261 lifted2610 = new lifted261();
                  lifted2610.v_122 = v_122;
                  lifted2610.t_122 = t_122;
                  lifted2610.u_122 = u_122;
                  term = fetch_elem_1_0.instance.invoke(context, term, lifted2610);
                  if(term == null)
                    break Fail426;
                }
              }
            }
          }
        }
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class $Assertion3_0_0 extends Strategy 
  { 
    public static $Assertion3_0_0 instance = new $Assertion3_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      ITermFactory termFactory = context.getFactory();
      context.push("Assertion3_0_0");
      Fail432:
      { 
        IStrategoTerm term525 = term;
        Success313:
        { 
          Fail433:
          { 
            TermReference c_139 = new TermReference();
            TermReference d_139 = new TermReference();
            TermReference e_139 = new TermReference();
            IStrategoTerm h_139 = null;
            IStrategoTerm j_139 = null;
            IStrategoTerm w_139 = null;
            if(d_139.value == null)
              d_139.value = term;
            else
              if(d_139.value != term && !d_139.value.match(term))
                break Fail433;
            if(term.getTermType() != IStrategoTerm.APPL || Simplify._consEqu_2 != ((IStrategoAppl)term).getConstructor())
              break Fail433;
            if(e_139.value == null)
              e_139.value = term.getSubterm(0);
            else
              if(e_139.value != term.getSubterm(0) && !e_139.value.match(term.getSubterm(0)))
                break Fail433;
            IStrategoTerm arg933 = term.getSubterm(1);
            if(arg933.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg933).getConstructor())
              break Fail433;
            if(c_139.value == null)
              c_139.value = arg933.getSubterm(0);
            else
              if(c_139.value != arg933.getSubterm(0) && !c_139.value.match(arg933.getSubterm(0)))
                break Fail433;
            j_139 = term;
            h_139 = Simplify.const57;
            term = j_139;
            w_139 = j_139;
            if(e_139.value == null)
              break Fail433;
            term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consEqu_2, new IStrategoTerm[]{e_139.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
            term = dr_lookup_rule_0_2.instance.invoke(context, w_139, h_139, term);
            if(term == null)
              break Fail433;
            lifted262 lifted2620 = new lifted262();
            lifted2620.e_139 = e_139;
            lifted2620.c_139 = c_139;
            lifted2620.d_139 = d_139;
            term = fetch_elem_1_0.instance.invoke(context, term, lifted2620);
            if(term == null)
              break Fail433;
            if(true)
              break Success313;
          }
          term = term525;
          IStrategoTerm term526 = term;
          Success314:
          { 
            Fail434:
            { 
              TermReference t_138 = new TermReference();
              TermReference u_138 = new TermReference();
              TermReference v_138 = new TermReference();
              IStrategoTerm y_138 = null;
              IStrategoTerm a_139 = null;
              IStrategoTerm b_139 = null;
              if(u_138.value == null)
                u_138.value = term;
              else
                if(u_138.value != term && !u_138.value.match(term))
                  break Fail434;
              if(term.getTermType() != IStrategoTerm.APPL || Simplify._consLeq_2 != ((IStrategoAppl)term).getConstructor())
                break Fail434;
              if(v_138.value == null)
                v_138.value = term.getSubterm(0);
              else
                if(v_138.value != term.getSubterm(0) && !v_138.value.match(term.getSubterm(0)))
                  break Fail434;
              IStrategoTerm arg934 = term.getSubterm(1);
              if(arg934.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg934).getConstructor())
                break Fail434;
              if(t_138.value == null)
                t_138.value = arg934.getSubterm(0);
              else
                if(t_138.value != arg934.getSubterm(0) && !t_138.value.match(arg934.getSubterm(0)))
                  break Fail434;
              a_139 = term;
              y_138 = Simplify.const57;
              term = a_139;
              b_139 = a_139;
              if(v_138.value == null)
                break Fail434;
              term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consLeq_2, new IStrategoTerm[]{v_138.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
              term = dr_lookup_rule_0_2.instance.invoke(context, b_139, y_138, term);
              if(term == null)
                break Fail434;
              lifted263 lifted2630 = new lifted263();
              lifted2630.v_138 = v_138;
              lifted2630.t_138 = t_138;
              lifted2630.u_138 = u_138;
              term = fetch_elem_1_0.instance.invoke(context, term, lifted2630);
              if(term == null)
                break Fail434;
              if(true)
                break Success314;
            }
            term = term526;
            IStrategoTerm term527 = term;
            Success315:
            { 
              Fail435:
              { 
                TermReference h_138 = new TermReference();
                TermReference i_138 = new TermReference();
                TermReference j_138 = new TermReference();
                IStrategoTerm m_138 = null;
                IStrategoTerm o_138 = null;
                IStrategoTerm p_138 = null;
                if(i_138.value == null)
                  i_138.value = term;
                else
                  if(i_138.value != term && !i_138.value.match(term))
                    break Fail435;
                if(term.getTermType() != IStrategoTerm.APPL || Simplify._consLt_2 != ((IStrategoAppl)term).getConstructor())
                  break Fail435;
                if(j_138.value == null)
                  j_138.value = term.getSubterm(0);
                else
                  if(j_138.value != term.getSubterm(0) && !j_138.value.match(term.getSubterm(0)))
                    break Fail435;
                IStrategoTerm arg935 = term.getSubterm(1);
                if(arg935.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg935).getConstructor())
                  break Fail435;
                if(h_138.value == null)
                  h_138.value = arg935.getSubterm(0);
                else
                  if(h_138.value != arg935.getSubterm(0) && !h_138.value.match(arg935.getSubterm(0)))
                    break Fail435;
                o_138 = term;
                m_138 = Simplify.const57;
                term = o_138;
                p_138 = o_138;
                if(j_138.value == null)
                  break Fail435;
                term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consLt_2, new IStrategoTerm[]{j_138.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
                term = dr_lookup_rule_0_2.instance.invoke(context, p_138, m_138, term);
                if(term == null)
                  break Fail435;
                lifted264 lifted2640 = new lifted264();
                lifted2640.j_138 = j_138;
                lifted2640.h_138 = h_138;
                lifted2640.i_138 = i_138;
                term = fetch_elem_1_0.instance.invoke(context, term, lifted2640);
                if(term == null)
                  break Fail435;
                if(true)
                  break Success315;
              }
              term = term527;
              IStrategoTerm term528 = term;
              Success316:
              { 
                Fail436:
                { 
                  TermReference v_137 = new TermReference();
                  TermReference z_137 = new TermReference();
                  TermReference a_138 = new TermReference();
                  IStrategoTerm d_138 = null;
                  IStrategoTerm f_138 = null;
                  IStrategoTerm g_138 = null;
                  if(z_137.value == null)
                    z_137.value = term;
                  else
                    if(z_137.value != term && !z_137.value.match(term))
                      break Fail436;
                  if(term.getTermType() != IStrategoTerm.APPL || Simplify._consNeq_2 != ((IStrategoAppl)term).getConstructor())
                    break Fail436;
                  if(a_138.value == null)
                    a_138.value = term.getSubterm(0);
                  else
                    if(a_138.value != term.getSubterm(0) && !a_138.value.match(term.getSubterm(0)))
                      break Fail436;
                  IStrategoTerm arg936 = term.getSubterm(1);
                  if(arg936.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg936).getConstructor())
                    break Fail436;
                  if(v_137.value == null)
                    v_137.value = arg936.getSubterm(0);
                  else
                    if(v_137.value != arg936.getSubterm(0) && !v_137.value.match(arg936.getSubterm(0)))
                      break Fail436;
                  f_138 = term;
                  d_138 = Simplify.const57;
                  term = f_138;
                  g_138 = f_138;
                  if(a_138.value == null)
                    break Fail436;
                  term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consNeq_2, new IStrategoTerm[]{a_138.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
                  term = dr_lookup_rule_0_2.instance.invoke(context, g_138, d_138, term);
                  if(term == null)
                    break Fail436;
                  lifted265 lifted2650 = new lifted265();
                  lifted2650.a_138 = a_138;
                  lifted2650.v_137 = v_137;
                  lifted2650.z_137 = z_137;
                  term = fetch_elem_1_0.instance.invoke(context, term, lifted2650);
                  if(term == null)
                    break Fail436;
                  if(true)
                    break Success316;
                }
                term = term528;
                IStrategoTerm term529 = term;
                Success317:
                { 
                  Fail437:
                  { 
                    TermReference m_137 = new TermReference();
                    TermReference n_137 = new TermReference();
                    TermReference o_137 = new TermReference();
                    IStrategoTerm r_137 = null;
                    IStrategoTerm t_137 = null;
                    IStrategoTerm u_137 = null;
                    if(n_137.value == null)
                      n_137.value = term;
                    else
                      if(n_137.value != term && !n_137.value.match(term))
                        break Fail437;
                    if(term.getTermType() != IStrategoTerm.APPL || Simplify._consGeq_2 != ((IStrategoAppl)term).getConstructor())
                      break Fail437;
                    if(o_137.value == null)
                      o_137.value = term.getSubterm(0);
                    else
                      if(o_137.value != term.getSubterm(0) && !o_137.value.match(term.getSubterm(0)))
                        break Fail437;
                    IStrategoTerm arg937 = term.getSubterm(1);
                    if(arg937.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg937).getConstructor())
                      break Fail437;
                    if(m_137.value == null)
                      m_137.value = arg937.getSubterm(0);
                    else
                      if(m_137.value != arg937.getSubterm(0) && !m_137.value.match(arg937.getSubterm(0)))
                        break Fail437;
                    t_137 = term;
                    r_137 = Simplify.const57;
                    term = t_137;
                    u_137 = t_137;
                    if(o_137.value == null)
                      break Fail437;
                    term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consGeq_2, new IStrategoTerm[]{o_137.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
                    term = dr_lookup_rule_0_2.instance.invoke(context, u_137, r_137, term);
                    if(term == null)
                      break Fail437;
                    lifted266 lifted2660 = new lifted266();
                    lifted2660.o_137 = o_137;
                    lifted2660.m_137 = m_137;
                    lifted2660.n_137 = n_137;
                    term = fetch_elem_1_0.instance.invoke(context, term, lifted2660);
                    if(term == null)
                      break Fail437;
                    if(true)
                      break Success317;
                  }
                  term = term529;
                  TermReference d_137 = new TermReference();
                  TermReference e_137 = new TermReference();
                  TermReference f_137 = new TermReference();
                  IStrategoTerm i_137 = null;
                  IStrategoTerm k_137 = null;
                  IStrategoTerm l_137 = null;
                  if(e_137.value == null)
                    e_137.value = term;
                  else
                    if(e_137.value != term && !e_137.value.match(term))
                      break Fail432;
                  if(term.getTermType() != IStrategoTerm.APPL || Simplify._consGt_2 != ((IStrategoAppl)term).getConstructor())
                    break Fail432;
                  if(f_137.value == null)
                    f_137.value = term.getSubterm(0);
                  else
                    if(f_137.value != term.getSubterm(0) && !f_137.value.match(term.getSubterm(0)))
                      break Fail432;
                  IStrategoTerm arg938 = term.getSubterm(1);
                  if(arg938.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg938).getConstructor())
                    break Fail432;
                  if(d_137.value == null)
                    d_137.value = arg938.getSubterm(0);
                  else
                    if(d_137.value != arg938.getSubterm(0) && !d_137.value.match(arg938.getSubterm(0)))
                      break Fail432;
                  k_137 = term;
                  i_137 = Simplify.const57;
                  term = k_137;
                  l_137 = k_137;
                  if(f_137.value == null)
                    break Fail432;
                  term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consGt_2, new IStrategoTerm[]{f_137.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
                  term = dr_lookup_rule_0_2.instance.invoke(context, l_137, i_137, term);
                  if(term == null)
                    break Fail432;
                  lifted267 lifted2670 = new lifted267();
                  lifted2670.f_137 = f_137;
                  lifted2670.d_137 = d_137;
                  lifted2670.e_137 = e_137;
                  term = fetch_elem_1_0.instance.invoke(context, term, lifted2670);
                  if(term == null)
                    break Fail432;
                }
              }
            }
          }
        }
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class $Assertion2_0_0 extends Strategy 
  { 
    public static $Assertion2_0_0 instance = new $Assertion2_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      ITermFactory termFactory = context.getFactory();
      context.push("Assertion2_0_0");
      Fail438:
      { 
        IStrategoTerm term530 = term;
        Success318:
        { 
          Fail439:
          { 
            TermReference o_154 = new TermReference();
            TermReference p_154 = new TermReference();
            TermReference q_154 = new TermReference();
            IStrategoTerm x_154 = null;
            IStrategoTerm c_155 = null;
            IStrategoTerm d_155 = null;
            if(p_154.value == null)
              p_154.value = term;
            else
              if(p_154.value != term && !p_154.value.match(term))
                break Fail439;
            if(term.getTermType() != IStrategoTerm.APPL || Simplify._consEqu_2 != ((IStrategoAppl)term).getConstructor())
              break Fail439;
            if(q_154.value == null)
              q_154.value = term.getSubterm(0);
            else
              if(q_154.value != term.getSubterm(0) && !q_154.value.match(term.getSubterm(0)))
                break Fail439;
            IStrategoTerm arg939 = term.getSubterm(1);
            if(arg939.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg939).getConstructor())
              break Fail439;
            if(o_154.value == null)
              o_154.value = arg939.getSubterm(0);
            else
              if(o_154.value != arg939.getSubterm(0) && !o_154.value.match(arg939.getSubterm(0)))
                break Fail439;
            c_155 = term;
            x_154 = Simplify.const55;
            term = c_155;
            d_155 = c_155;
            if(q_154.value == null)
              break Fail439;
            term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consEqu_2, new IStrategoTerm[]{q_154.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
            term = dr_lookup_rule_0_2.instance.invoke(context, d_155, x_154, term);
            if(term == null)
              break Fail439;
            lifted268 lifted2680 = new lifted268();
            lifted2680.q_154 = q_154;
            lifted2680.o_154 = o_154;
            lifted2680.p_154 = p_154;
            term = fetch_elem_1_0.instance.invoke(context, term, lifted2680);
            if(term == null)
              break Fail439;
            if(true)
              break Success318;
          }
          term = term530;
          IStrategoTerm term531 = term;
          Success319:
          { 
            Fail440:
            { 
              TermReference z_153 = new TermReference();
              TermReference a_154 = new TermReference();
              TermReference b_154 = new TermReference();
              IStrategoTerm h_154 = null;
              IStrategoTerm j_154 = null;
              IStrategoTerm k_154 = null;
              if(a_154.value == null)
                a_154.value = term;
              else
                if(a_154.value != term && !a_154.value.match(term))
                  break Fail440;
              if(term.getTermType() != IStrategoTerm.APPL || Simplify._consGeq_2 != ((IStrategoAppl)term).getConstructor())
                break Fail440;
              if(b_154.value == null)
                b_154.value = term.getSubterm(0);
              else
                if(b_154.value != term.getSubterm(0) && !b_154.value.match(term.getSubterm(0)))
                  break Fail440;
              IStrategoTerm arg940 = term.getSubterm(1);
              if(arg940.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg940).getConstructor())
                break Fail440;
              if(z_153.value == null)
                z_153.value = arg940.getSubterm(0);
              else
                if(z_153.value != arg940.getSubterm(0) && !z_153.value.match(arg940.getSubterm(0)))
                  break Fail440;
              j_154 = term;
              h_154 = Simplify.const55;
              term = j_154;
              k_154 = j_154;
              if(b_154.value == null)
                break Fail440;
              term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consGeq_2, new IStrategoTerm[]{b_154.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
              term = dr_lookup_rule_0_2.instance.invoke(context, k_154, h_154, term);
              if(term == null)
                break Fail440;
              lifted269 lifted2690 = new lifted269();
              lifted2690.b_154 = b_154;
              lifted2690.z_153 = z_153;
              lifted2690.a_154 = a_154;
              term = fetch_elem_1_0.instance.invoke(context, term, lifted2690);
              if(term == null)
                break Fail440;
              if(true)
                break Success319;
            }
            term = term531;
            IStrategoTerm term532 = term;
            Success320:
            { 
              Fail441:
              { 
                TermReference u_152 = new TermReference();
                TermReference y_152 = new TermReference();
                TermReference j_153 = new TermReference();
                IStrategoTerm s_153 = null;
                IStrategoTerm x_153 = null;
                IStrategoTerm y_153 = null;
                if(y_152.value == null)
                  y_152.value = term;
                else
                  if(y_152.value != term && !y_152.value.match(term))
                    break Fail441;
                if(term.getTermType() != IStrategoTerm.APPL || Simplify._consGt_2 != ((IStrategoAppl)term).getConstructor())
                  break Fail441;
                if(j_153.value == null)
                  j_153.value = term.getSubterm(0);
                else
                  if(j_153.value != term.getSubterm(0) && !j_153.value.match(term.getSubterm(0)))
                    break Fail441;
                IStrategoTerm arg941 = term.getSubterm(1);
                if(arg941.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg941).getConstructor())
                  break Fail441;
                if(u_152.value == null)
                  u_152.value = arg941.getSubterm(0);
                else
                  if(u_152.value != arg941.getSubterm(0) && !u_152.value.match(arg941.getSubterm(0)))
                    break Fail441;
                x_153 = term;
                s_153 = Simplify.const55;
                term = x_153;
                y_153 = x_153;
                if(j_153.value == null)
                  break Fail441;
                term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consGt_2, new IStrategoTerm[]{j_153.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
                term = dr_lookup_rule_0_2.instance.invoke(context, y_153, s_153, term);
                if(term == null)
                  break Fail441;
                lifted270 lifted2700 = new lifted270();
                lifted2700.j_153 = j_153;
                lifted2700.u_152 = u_152;
                lifted2700.y_152 = y_152;
                term = fetch_elem_1_0.instance.invoke(context, term, lifted2700);
                if(term == null)
                  break Fail441;
                if(true)
                  break Success320;
              }
              term = term532;
              IStrategoTerm term533 = term;
              Success321:
              { 
                Fail442:
                { 
                  TermReference y_151 = new TermReference();
                  TermReference d_152 = new TermReference();
                  TermReference g_152 = new TermReference();
                  IStrategoTerm m_152 = null;
                  IStrategoTerm o_152 = null;
                  IStrategoTerm t_152 = null;
                  if(d_152.value == null)
                    d_152.value = term;
                  else
                    if(d_152.value != term && !d_152.value.match(term))
                      break Fail442;
                  if(term.getTermType() != IStrategoTerm.APPL || Simplify._consNeq_2 != ((IStrategoAppl)term).getConstructor())
                    break Fail442;
                  if(g_152.value == null)
                    g_152.value = term.getSubterm(0);
                  else
                    if(g_152.value != term.getSubterm(0) && !g_152.value.match(term.getSubterm(0)))
                      break Fail442;
                  IStrategoTerm arg942 = term.getSubterm(1);
                  if(arg942.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg942).getConstructor())
                    break Fail442;
                  if(y_151.value == null)
                    y_151.value = arg942.getSubterm(0);
                  else
                    if(y_151.value != arg942.getSubterm(0) && !y_151.value.match(arg942.getSubterm(0)))
                      break Fail442;
                  o_152 = term;
                  m_152 = Simplify.const55;
                  term = o_152;
                  t_152 = o_152;
                  if(g_152.value == null)
                    break Fail442;
                  term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consNeq_2, new IStrategoTerm[]{g_152.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
                  term = dr_lookup_rule_0_2.instance.invoke(context, t_152, m_152, term);
                  if(term == null)
                    break Fail442;
                  lifted271 lifted2710 = new lifted271();
                  lifted2710.g_152 = g_152;
                  lifted2710.y_151 = y_151;
                  lifted2710.d_152 = d_152;
                  term = fetch_elem_1_0.instance.invoke(context, term, lifted2710);
                  if(term == null)
                    break Fail442;
                  if(true)
                    break Success321;
                }
                term = term533;
                IStrategoTerm term534 = term;
                Success322:
                { 
                  Fail443:
                  { 
                    TermReference k_151 = new TermReference();
                    TermReference l_151 = new TermReference();
                    TermReference m_151 = new TermReference();
                    IStrategoTerm r_151 = null;
                    IStrategoTerm w_151 = null;
                    IStrategoTerm x_151 = null;
                    if(l_151.value == null)
                      l_151.value = term;
                    else
                      if(l_151.value != term && !l_151.value.match(term))
                        break Fail443;
                    if(term.getTermType() != IStrategoTerm.APPL || Simplify._consLeq_2 != ((IStrategoAppl)term).getConstructor())
                      break Fail443;
                    if(m_151.value == null)
                      m_151.value = term.getSubterm(0);
                    else
                      if(m_151.value != term.getSubterm(0) && !m_151.value.match(term.getSubterm(0)))
                        break Fail443;
                    IStrategoTerm arg943 = term.getSubterm(1);
                    if(arg943.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg943).getConstructor())
                      break Fail443;
                    if(k_151.value == null)
                      k_151.value = arg943.getSubterm(0);
                    else
                      if(k_151.value != arg943.getSubterm(0) && !k_151.value.match(arg943.getSubterm(0)))
                        break Fail443;
                    w_151 = term;
                    r_151 = Simplify.const55;
                    term = w_151;
                    x_151 = w_151;
                    if(m_151.value == null)
                      break Fail443;
                    term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consLeq_2, new IStrategoTerm[]{m_151.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
                    term = dr_lookup_rule_0_2.instance.invoke(context, x_151, r_151, term);
                    if(term == null)
                      break Fail443;
                    lifted272 lifted2720 = new lifted272();
                    lifted2720.m_151 = m_151;
                    lifted2720.k_151 = k_151;
                    lifted2720.l_151 = l_151;
                    term = fetch_elem_1_0.instance.invoke(context, term, lifted2720);
                    if(term == null)
                      break Fail443;
                    if(true)
                      break Success322;
                  }
                  term = term534;
                  TermReference y_150 = new TermReference();
                  TermReference z_150 = new TermReference();
                  TermReference c_151 = new TermReference();
                  IStrategoTerm f_151 = null;
                  IStrategoTerm h_151 = null;
                  IStrategoTerm j_151 = null;
                  if(z_150.value == null)
                    z_150.value = term;
                  else
                    if(z_150.value != term && !z_150.value.match(term))
                      break Fail438;
                  if(term.getTermType() != IStrategoTerm.APPL || Simplify._consLt_2 != ((IStrategoAppl)term).getConstructor())
                    break Fail438;
                  if(c_151.value == null)
                    c_151.value = term.getSubterm(0);
                  else
                    if(c_151.value != term.getSubterm(0) && !c_151.value.match(term.getSubterm(0)))
                      break Fail438;
                  IStrategoTerm arg944 = term.getSubterm(1);
                  if(arg944.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg944).getConstructor())
                    break Fail438;
                  if(y_150.value == null)
                    y_150.value = arg944.getSubterm(0);
                  else
                    if(y_150.value != arg944.getSubterm(0) && !y_150.value.match(arg944.getSubterm(0)))
                      break Fail438;
                  h_151 = term;
                  f_151 = Simplify.const55;
                  term = h_151;
                  j_151 = h_151;
                  if(c_151.value == null)
                    break Fail438;
                  term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consLt_2, new IStrategoTerm[]{c_151.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
                  term = dr_lookup_rule_0_2.instance.invoke(context, j_151, f_151, term);
                  if(term == null)
                    break Fail438;
                  lifted273 lifted2730 = new lifted273();
                  lifted2730.c_151 = c_151;
                  lifted2730.y_150 = y_150;
                  lifted2730.z_150 = z_150;
                  term = fetch_elem_1_0.instance.invoke(context, term, lifted2730);
                  if(term == null)
                    break Fail438;
                }
              }
            }
          }
        }
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class $Assertion1_0_0 extends Strategy 
  { 
    public static $Assertion1_0_0 instance = new $Assertion1_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      ITermFactory termFactory = context.getFactory();
      context.push("Assertion1_0_0");
      Fail444:
      { 
        IStrategoTerm term535 = term;
        Success323:
        { 
          Fail445:
          { 
            TermReference o_168 = new TermReference();
            TermReference p_168 = new TermReference();
            TermReference q_168 = new TermReference();
            IStrategoTerm t_168 = null;
            IStrategoTerm v_168 = null;
            IStrategoTerm w_168 = null;
            if(p_168.value == null)
              p_168.value = term;
            else
              if(p_168.value != term && !p_168.value.match(term))
                break Fail445;
            if(term.getTermType() != IStrategoTerm.APPL || Simplify._consEqu_2 != ((IStrategoAppl)term).getConstructor())
              break Fail445;
            if(q_168.value == null)
              q_168.value = term.getSubterm(0);
            else
              if(q_168.value != term.getSubterm(0) && !q_168.value.match(term.getSubterm(0)))
                break Fail445;
            IStrategoTerm arg945 = term.getSubterm(1);
            if(arg945.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg945).getConstructor())
              break Fail445;
            if(o_168.value == null)
              o_168.value = arg945.getSubterm(0);
            else
              if(o_168.value != arg945.getSubterm(0) && !o_168.value.match(arg945.getSubterm(0)))
                break Fail445;
            v_168 = term;
            t_168 = Simplify.const62;
            term = v_168;
            w_168 = v_168;
            if(q_168.value == null)
              break Fail445;
            term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consEqu_2, new IStrategoTerm[]{q_168.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
            term = dr_lookup_rule_0_2.instance.invoke(context, w_168, t_168, term);
            if(term == null)
              break Fail445;
            lifted274 lifted2740 = new lifted274();
            lifted2740.q_168 = q_168;
            lifted2740.o_168 = o_168;
            lifted2740.p_168 = p_168;
            term = fetch_elem_1_0.instance.invoke(context, term, lifted2740);
            if(term == null)
              break Fail445;
            if(true)
              break Success323;
          }
          term = term535;
          IStrategoTerm term536 = term;
          Success324:
          { 
            Fail446:
            { 
              TermReference f_168 = new TermReference();
              TermReference g_168 = new TermReference();
              TermReference h_168 = new TermReference();
              IStrategoTerm k_168 = null;
              IStrategoTerm m_168 = null;
              IStrategoTerm n_168 = null;
              if(g_168.value == null)
                g_168.value = term;
              else
                if(g_168.value != term && !g_168.value.match(term))
                  break Fail446;
              if(term.getTermType() != IStrategoTerm.APPL || Simplify._consGeq_2 != ((IStrategoAppl)term).getConstructor())
                break Fail446;
              if(h_168.value == null)
                h_168.value = term.getSubterm(0);
              else
                if(h_168.value != term.getSubterm(0) && !h_168.value.match(term.getSubterm(0)))
                  break Fail446;
              IStrategoTerm arg946 = term.getSubterm(1);
              if(arg946.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg946).getConstructor())
                break Fail446;
              if(f_168.value == null)
                f_168.value = arg946.getSubterm(0);
              else
                if(f_168.value != arg946.getSubterm(0) && !f_168.value.match(arg946.getSubterm(0)))
                  break Fail446;
              m_168 = term;
              k_168 = Simplify.const62;
              term = m_168;
              n_168 = m_168;
              if(h_168.value == null)
                break Fail446;
              term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consGeq_2, new IStrategoTerm[]{h_168.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
              term = dr_lookup_rule_0_2.instance.invoke(context, n_168, k_168, term);
              if(term == null)
                break Fail446;
              lifted275 lifted2750 = new lifted275();
              lifted2750.h_168 = h_168;
              lifted2750.f_168 = f_168;
              lifted2750.g_168 = g_168;
              term = fetch_elem_1_0.instance.invoke(context, term, lifted2750);
              if(term == null)
                break Fail446;
              if(true)
                break Success324;
            }
            term = term536;
            IStrategoTerm term537 = term;
            Success325:
            { 
              Fail447:
              { 
                TermReference w_167 = new TermReference();
                TermReference x_167 = new TermReference();
                TermReference y_167 = new TermReference();
                IStrategoTerm b_168 = null;
                IStrategoTerm d_168 = null;
                IStrategoTerm e_168 = null;
                if(x_167.value == null)
                  x_167.value = term;
                else
                  if(x_167.value != term && !x_167.value.match(term))
                    break Fail447;
                if(term.getTermType() != IStrategoTerm.APPL || Simplify._consGt_2 != ((IStrategoAppl)term).getConstructor())
                  break Fail447;
                if(y_167.value == null)
                  y_167.value = term.getSubterm(0);
                else
                  if(y_167.value != term.getSubterm(0) && !y_167.value.match(term.getSubterm(0)))
                    break Fail447;
                IStrategoTerm arg947 = term.getSubterm(1);
                if(arg947.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg947).getConstructor())
                  break Fail447;
                if(w_167.value == null)
                  w_167.value = arg947.getSubterm(0);
                else
                  if(w_167.value != arg947.getSubterm(0) && !w_167.value.match(arg947.getSubterm(0)))
                    break Fail447;
                d_168 = term;
                b_168 = Simplify.const62;
                term = d_168;
                e_168 = d_168;
                if(y_167.value == null)
                  break Fail447;
                term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consGt_2, new IStrategoTerm[]{y_167.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
                term = dr_lookup_rule_0_2.instance.invoke(context, e_168, b_168, term);
                if(term == null)
                  break Fail447;
                lifted276 lifted2760 = new lifted276();
                lifted2760.y_167 = y_167;
                lifted2760.w_167 = w_167;
                lifted2760.x_167 = x_167;
                term = fetch_elem_1_0.instance.invoke(context, term, lifted2760);
                if(term == null)
                  break Fail447;
                if(true)
                  break Success325;
              }
              term = term537;
              IStrategoTerm term538 = term;
              Success326:
              { 
                Fail448:
                { 
                  TermReference m_167 = new TermReference();
                  TermReference n_167 = new TermReference();
                  TermReference o_167 = new TermReference();
                  IStrategoTerm s_167 = null;
                  IStrategoTerm u_167 = null;
                  IStrategoTerm v_167 = null;
                  if(n_167.value == null)
                    n_167.value = term;
                  else
                    if(n_167.value != term && !n_167.value.match(term))
                      break Fail448;
                  if(term.getTermType() != IStrategoTerm.APPL || Simplify._consNeq_2 != ((IStrategoAppl)term).getConstructor())
                    break Fail448;
                  if(o_167.value == null)
                    o_167.value = term.getSubterm(0);
                  else
                    if(o_167.value != term.getSubterm(0) && !o_167.value.match(term.getSubterm(0)))
                      break Fail448;
                  IStrategoTerm arg948 = term.getSubterm(1);
                  if(arg948.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg948).getConstructor())
                    break Fail448;
                  if(m_167.value == null)
                    m_167.value = arg948.getSubterm(0);
                  else
                    if(m_167.value != arg948.getSubterm(0) && !m_167.value.match(arg948.getSubterm(0)))
                      break Fail448;
                  u_167 = term;
                  s_167 = Simplify.const62;
                  term = u_167;
                  v_167 = u_167;
                  if(o_167.value == null)
                    break Fail448;
                  term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consNeq_2, new IStrategoTerm[]{o_167.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
                  term = dr_lookup_rule_0_2.instance.invoke(context, v_167, s_167, term);
                  if(term == null)
                    break Fail448;
                  lifted277 lifted2770 = new lifted277();
                  lifted2770.o_167 = o_167;
                  lifted2770.m_167 = m_167;
                  lifted2770.n_167 = n_167;
                  term = fetch_elem_1_0.instance.invoke(context, term, lifted2770);
                  if(term == null)
                    break Fail448;
                  if(true)
                    break Success326;
                }
                term = term538;
                IStrategoTerm term539 = term;
                Success327:
                { 
                  Fail449:
                  { 
                    TermReference c_167 = new TermReference();
                    TermReference d_167 = new TermReference();
                    TermReference e_167 = new TermReference();
                    IStrategoTerm h_167 = null;
                    IStrategoTerm k_167 = null;
                    IStrategoTerm l_167 = null;
                    if(d_167.value == null)
                      d_167.value = term;
                    else
                      if(d_167.value != term && !d_167.value.match(term))
                        break Fail449;
                    if(term.getTermType() != IStrategoTerm.APPL || Simplify._consLeq_2 != ((IStrategoAppl)term).getConstructor())
                      break Fail449;
                    if(e_167.value == null)
                      e_167.value = term.getSubterm(0);
                    else
                      if(e_167.value != term.getSubterm(0) && !e_167.value.match(term.getSubterm(0)))
                        break Fail449;
                    IStrategoTerm arg949 = term.getSubterm(1);
                    if(arg949.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg949).getConstructor())
                      break Fail449;
                    if(c_167.value == null)
                      c_167.value = arg949.getSubterm(0);
                    else
                      if(c_167.value != arg949.getSubterm(0) && !c_167.value.match(arg949.getSubterm(0)))
                        break Fail449;
                    k_167 = term;
                    h_167 = Simplify.const62;
                    term = k_167;
                    l_167 = k_167;
                    if(e_167.value == null)
                      break Fail449;
                    term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consLeq_2, new IStrategoTerm[]{e_167.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
                    term = dr_lookup_rule_0_2.instance.invoke(context, l_167, h_167, term);
                    if(term == null)
                      break Fail449;
                    lifted278 lifted2780 = new lifted278();
                    lifted2780.e_167 = e_167;
                    lifted2780.c_167 = c_167;
                    lifted2780.d_167 = d_167;
                    term = fetch_elem_1_0.instance.invoke(context, term, lifted2780);
                    if(term == null)
                      break Fail449;
                    if(true)
                      break Success327;
                  }
                  term = term539;
                  TermReference t_166 = new TermReference();
                  TermReference u_166 = new TermReference();
                  TermReference v_166 = new TermReference();
                  IStrategoTerm y_166 = null;
                  IStrategoTerm a_167 = null;
                  IStrategoTerm b_167 = null;
                  if(u_166.value == null)
                    u_166.value = term;
                  else
                    if(u_166.value != term && !u_166.value.match(term))
                      break Fail444;
                  if(term.getTermType() != IStrategoTerm.APPL || Simplify._consLt_2 != ((IStrategoAppl)term).getConstructor())
                    break Fail444;
                  if(v_166.value == null)
                    v_166.value = term.getSubterm(0);
                  else
                    if(v_166.value != term.getSubterm(0) && !v_166.value.match(term.getSubterm(0)))
                      break Fail444;
                  IStrategoTerm arg950 = term.getSubterm(1);
                  if(arg950.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg950).getConstructor())
                    break Fail444;
                  if(t_166.value == null)
                    t_166.value = arg950.getSubterm(0);
                  else
                    if(t_166.value != arg950.getSubterm(0) && !t_166.value.match(arg950.getSubterm(0)))
                      break Fail444;
                  a_167 = term;
                  y_166 = Simplify.const62;
                  term = a_167;
                  b_167 = a_167;
                  if(v_166.value == null)
                    break Fail444;
                  term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consLt_2, new IStrategoTerm[]{v_166.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
                  term = dr_lookup_rule_0_2.instance.invoke(context, b_167, y_166, term);
                  if(term == null)
                    break Fail444;
                  lifted279 lifted2790 = new lifted279();
                  lifted2790.v_166 = v_166;
                  lifted2790.t_166 = t_166;
                  lifted2790.u_166 = u_166;
                  term = fetch_elem_1_0.instance.invoke(context, term, lifted2790);
                  if(term == null)
                    break Fail444;
                }
              }
            }
          }
        }
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class bagof_$Used$In$Assertion_0_0 extends Strategy 
  { 
    public static bagof_$Used$In$Assertion_0_0 instance = new bagof_$Used$In$Assertion_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      ITermFactory termFactory = context.getFactory();
      context.push("bagof_UsedInAssertion_0_0");
      Fail450:
      { 
        TermReference k_170 = new TermReference();
        TermReference m_170 = new TermReference();
        if(k_170.value == null)
          k_170.value = term;
        else
          if(k_170.value != term && !k_170.value.match(term))
            break Fail450;
        if(term.getTermType() != IStrategoTerm.APPL || Simplify._consVar_1 != ((IStrategoAppl)term).getConstructor())
          break Fail450;
        if(m_170.value == null)
          m_170.value = term.getSubterm(0);
        else
          if(m_170.value != term.getSubterm(0) && !m_170.value.match(term.getSubterm(0)))
            break Fail450;
        Success328:
        { 
          Fail451:
          { 
            IStrategoTerm p_170 = null;
            IStrategoTerm s_170 = null;
            IStrategoTerm t_170 = null;
            s_170 = term;
            p_170 = Simplify.const64;
            term = s_170;
            t_170 = s_170;
            if(m_170.value == null)
              break Fail451;
            term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consVar_1, new IStrategoTerm[]{m_170.value}), checkListAnnos(termFactory, Simplify.constCons16));
            term = dr_lookup_rule_0_2.instance.invoke(context, t_170, p_170, term);
            if(term == null)
              break Fail451;
            if(true)
              break Success328;
          }
          term = Simplify.constNil0;
        }
        lifted280 lifted2800 = new lifted280();
        lifted2800.m_170 = m_170;
        lifted2800.k_170 = k_170;
        term = filter_1_0.instance.invoke(context, term, lifted2800);
        if(term == null)
          break Fail450;
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class aux_$Used$In$Assertion_0_2 extends Strategy 
  { 
    public static aux_$Used$In$Assertion_0_2 instance = new aux_$Used$In$Assertion_0_2();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term, IStrategoTerm d_175, IStrategoTerm e_175)
    { 
      Fail452:
      { 
        IStrategoTerm f_175 = null;
        if(term.getTermType() != IStrategoTerm.TUPLE || term.getSubtermCount() != 2)
          break Fail452;
        IStrategoTerm arg951 = term.getSubterm(0);
        if(arg951.getTermType() != IStrategoTerm.STRING || !"-74369".equals(((IStrategoString)arg951).stringValue()))
          break Fail452;
        f_175 = term.getSubterm(1);
        term = f_175;
        if(true)
          return term;
      }
      context.push("aux_UsedInAssertion_0_2");
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class aux_$Assertion3_0_3 extends Strategy 
  { 
    public static aux_$Assertion3_0_3 instance = new aux_$Assertion3_0_3();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term, IStrategoTerm o_329, IStrategoTerm p_329, IStrategoTerm q_329)
    { 
      ITermFactory termFactory = context.getFactory();
      context.push("aux_Assertion3_0_3");
      Fail453:
      { 
        IStrategoTerm term541 = term;
        Success329:
        { 
          Fail454:
          { 
            IStrategoTerm o_199 = null;
            if(term.getTermType() != IStrategoTerm.TUPLE || term.getSubtermCount() != 2)
              break Fail454;
            IStrategoTerm arg952 = term.getSubterm(0);
            if(arg952.getTermType() != IStrategoTerm.STRING || !"-718286".equals(((IStrategoString)arg952).stringValue()))
              break Fail454;
            o_199 = term.getSubterm(1);
            term = termFactory.makeTuple(p_329, o_199);
            term = leq$S_0_0.instance.invoke(context, term);
            if(term == null)
              break Fail454;
            term = Simplify.constFalse0;
            if(true)
              break Success329;
          }
          term = term541;
          IStrategoTerm term542 = term;
          Success330:
          { 
            Fail455:
            { 
              IStrategoTerm j_199 = null;
              if(term.getTermType() != IStrategoTerm.TUPLE || term.getSubtermCount() != 2)
                break Fail455;
              IStrategoTerm arg953 = term.getSubterm(0);
              if(arg953.getTermType() != IStrategoTerm.STRING || !"-64755".equals(((IStrategoString)arg953).stringValue()))
                break Fail455;
              j_199 = term.getSubterm(1);
              term = termFactory.makeTuple(p_329, j_199);
              term = leq$S_0_0.instance.invoke(context, term);
              if(term == null)
                break Fail455;
              term = Simplify.constFalse0;
              if(true)
                break Success330;
            }
            term = term542;
            IStrategoTerm term543 = term;
            Success331:
            { 
              Fail456:
              { 
                IStrategoTerm c_199 = null;
                if(term.getTermType() != IStrategoTerm.TUPLE || term.getSubtermCount() != 2)
                  break Fail456;
                IStrategoTerm arg954 = term.getSubterm(0);
                if(arg954.getTermType() != IStrategoTerm.STRING || !"-409529".equals(((IStrategoString)arg954).stringValue()))
                  break Fail456;
                c_199 = term.getSubterm(1);
                term = termFactory.makeTuple(p_329, c_199);
                term = leq$S_0_0.instance.invoke(context, term);
                if(term == null)
                  break Fail456;
                term = Simplify.constFalse0;
                if(true)
                  break Success331;
              }
              term = term543;
              IStrategoTerm term544 = term;
              Success332:
              { 
                Fail457:
                { 
                  IStrategoTerm x_198 = null;
                  if(term.getTermType() != IStrategoTerm.TUPLE || term.getSubtermCount() != 2)
                    break Fail457;
                  IStrategoTerm arg955 = term.getSubterm(0);
                  if(arg955.getTermType() != IStrategoTerm.STRING || !"-342547".equals(((IStrategoString)arg955).stringValue()))
                    break Fail457;
                  x_198 = term.getSubterm(1);
                  term = termFactory.makeTuple(p_329, x_198);
                  term = leq$S_0_0.instance.invoke(context, term);
                  if(term == null)
                    break Fail457;
                  term = Simplify.constTrue0;
                  if(true)
                    break Success332;
                }
                term = term544;
                IStrategoTerm term545 = term;
                Success333:
                { 
                  Fail458:
                  { 
                    IStrategoTerm s_198 = null;
                    if(term.getTermType() != IStrategoTerm.TUPLE || term.getSubtermCount() != 2)
                      break Fail458;
                    IStrategoTerm arg956 = term.getSubterm(0);
                    if(arg956.getTermType() != IStrategoTerm.STRING || !"-402069".equals(((IStrategoString)arg956).stringValue()))
                      break Fail458;
                    s_198 = term.getSubterm(1);
                    term = termFactory.makeTuple(p_329, s_198);
                    term = leq$S_0_0.instance.invoke(context, term);
                    if(term == null)
                      break Fail458;
                    term = Simplify.constTrue0;
                    if(true)
                      break Success333;
                  }
                  term = term545;
                  IStrategoTerm m_198 = null;
                  if(term.getTermType() != IStrategoTerm.TUPLE || term.getSubtermCount() != 2)
                    break Fail453;
                  IStrategoTerm arg957 = term.getSubterm(0);
                  if(arg957.getTermType() != IStrategoTerm.STRING || !"74153".equals(((IStrategoString)arg957).stringValue()))
                    break Fail453;
                  m_198 = term.getSubterm(1);
                  term = termFactory.makeTuple(p_329, m_198);
                  term = leq$S_0_0.instance.invoke(context, term);
                  if(term == null)
                    break Fail453;
                  term = Simplify.constTrue0;
                }
              }
            }
          }
        }
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class aux_$Assertion4_0_3 extends Strategy 
  { 
    public static aux_$Assertion4_0_3 instance = new aux_$Assertion4_0_3();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term, IStrategoTerm y_329, IStrategoTerm z_329, IStrategoTerm a_330)
    { 
      ITermFactory termFactory = context.getFactory();
      context.push("aux_Assertion4_0_3");
      Fail459:
      { 
        IStrategoTerm term546 = term;
        Success334:
        { 
          Fail460:
          { 
            IStrategoTerm e_225 = null;
            if(term.getTermType() != IStrategoTerm.TUPLE || term.getSubtermCount() != 2)
              break Fail460;
            IStrategoTerm arg958 = term.getSubterm(0);
            if(arg958.getTermType() != IStrategoTerm.STRING || !"-718170".equals(((IStrategoString)arg958).stringValue()))
              break Fail460;
            e_225 = term.getSubterm(1);
            term = termFactory.makeTuple(z_329, e_225);
            term = lt$S_0_0.instance.invoke(context, term);
            if(term == null)
              break Fail460;
            term = Simplify.constFalse0;
            if(true)
              break Success334;
          }
          term = term546;
          IStrategoTerm term547 = term;
          Success335:
          { 
            Fail461:
            { 
              IStrategoTerm z_224 = null;
              if(term.getTermType() != IStrategoTerm.TUPLE || term.getSubtermCount() != 2)
                break Fail461;
              IStrategoTerm arg959 = term.getSubterm(0);
              if(arg959.getTermType() != IStrategoTerm.STRING || !"-64523".equals(((IStrategoString)arg959).stringValue()))
                break Fail461;
              z_224 = term.getSubterm(1);
              term = termFactory.makeTuple(z_329, z_224);
              term = lt$S_0_0.instance.invoke(context, term);
              if(term == null)
                break Fail461;
              term = Simplify.constFalse0;
              if(true)
                break Success335;
            }
            term = term547;
            IStrategoTerm term548 = term;
            Success336:
            { 
              Fail462:
              { 
                IStrategoTerm u_224 = null;
                if(term.getTermType() != IStrategoTerm.TUPLE || term.getSubtermCount() != 2)
                  break Fail462;
                IStrategoTerm arg960 = term.getSubterm(0);
                if(arg960.getTermType() != IStrategoTerm.STRING || !"-409298".equals(((IStrategoString)arg960).stringValue()))
                  break Fail462;
                u_224 = term.getSubterm(1);
                term = termFactory.makeTuple(z_329, u_224);
                term = leq$S_0_0.instance.invoke(context, term);
                if(term == null)
                  break Fail462;
                term = Simplify.constFalse0;
                if(true)
                  break Success336;
              }
              term = term548;
              IStrategoTerm term549 = term;
              Success337:
              { 
                Fail463:
                { 
                  IStrategoTerm p_224 = null;
                  if(term.getTermType() != IStrategoTerm.TUPLE || term.getSubtermCount() != 2)
                    break Fail463;
                  IStrategoTerm arg961 = term.getSubterm(0);
                  if(arg961.getTermType() != IStrategoTerm.STRING || !"-342316".equals(((IStrategoString)arg961).stringValue()))
                    break Fail463;
                  p_224 = term.getSubterm(1);
                  term = termFactory.makeTuple(z_329, p_224);
                  term = lt$S_0_0.instance.invoke(context, term);
                  if(term == null)
                    break Fail463;
                  term = Simplify.constTrue0;
                  if(true)
                    break Success337;
                }
                term = term549;
                IStrategoTerm term550 = term;
                Success338:
                { 
                  Fail464:
                  { 
                    IStrategoTerm g_224 = null;
                    if(term.getTermType() != IStrategoTerm.TUPLE || term.getSubtermCount() != 2)
                      break Fail464;
                    IStrategoTerm arg962 = term.getSubterm(0);
                    if(arg962.getTermType() != IStrategoTerm.STRING || !"-401954".equals(((IStrategoString)arg962).stringValue()))
                      break Fail464;
                    g_224 = term.getSubterm(1);
                    term = termFactory.makeTuple(z_329, g_224);
                    term = leq$S_0_0.instance.invoke(context, term);
                    if(term == null)
                      break Fail464;
                    term = Simplify.constTrue0;
                    if(true)
                      break Success338;
                  }
                  term = term550;
                  IStrategoTerm a_224 = null;
                  if(term.getTermType() != IStrategoTerm.TUPLE || term.getSubtermCount() != 2)
                    break Fail459;
                  IStrategoTerm arg963 = term.getSubterm(0);
                  if(arg963.getTermType() != IStrategoTerm.STRING || !"74384".equals(((IStrategoString)arg963).stringValue()))
                    break Fail459;
                  a_224 = term.getSubterm(1);
                  term = termFactory.makeTuple(z_329, a_224);
                  term = lt$S_0_0.instance.invoke(context, term);
                  if(term == null)
                    break Fail459;
                  term = Simplify.constTrue0;
                }
              }
            }
          }
        }
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class aux_$Assertion1_0_3 extends Strategy 
  { 
    public static aux_$Assertion1_0_3 instance = new aux_$Assertion1_0_3();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term, IStrategoTerm i_330, IStrategoTerm j_330, IStrategoTerm k_330)
    { 
      ITermFactory termFactory = context.getFactory();
      context.push("aux_Assertion1_0_3");
      Fail465:
      { 
        IStrategoTerm term551 = term;
        Success339:
        { 
          Fail466:
          { 
            IStrategoTerm m_251 = null;
            if(term.getTermType() != IStrategoTerm.TUPLE || term.getSubtermCount() != 2)
              break Fail466;
            IStrategoTerm arg964 = term.getSubterm(0);
            if(arg964.getTermType() != IStrategoTerm.STRING || !"-719674".equals(((IStrategoString)arg964).stringValue()))
              break Fail466;
            m_251 = term.getSubterm(1);
            term = termFactory.makeTuple(j_330, m_251);
            term = gt$S_0_0.instance.invoke(context, term);
            if(term == null)
              break Fail466;
            term = Simplify.constFalse0;
            if(true)
              break Success339;
          }
          term = term551;
          IStrategoTerm term552 = term;
          Success340:
          { 
            Fail467:
            { 
              IStrategoTerm h_251 = null;
              if(term.getTermType() != IStrategoTerm.TUPLE || term.getSubtermCount() != 2)
                break Fail467;
              IStrategoTerm arg965 = term.getSubterm(0);
              if(arg965.getTermType() != IStrategoTerm.STRING || !"-637146".equals(((IStrategoString)arg965).stringValue()))
                break Fail467;
              h_251 = term.getSubterm(1);
              term = termFactory.makeTuple(j_330, h_251);
              term = gt$S_0_0.instance.invoke(context, term);
              if(term == null)
                break Fail467;
              term = Simplify.constFalse0;
              if(true)
                break Success340;
            }
            term = term552;
            IStrategoTerm term553 = term;
            Success341:
            { 
              Fail468:
              { 
                IStrategoTerm b_251 = null;
                if(term.getTermType() != IStrategoTerm.TUPLE || term.getSubtermCount() != 2)
                  break Fail468;
                IStrategoTerm arg966 = term.getSubterm(0);
                if(arg966.getTermType() != IStrategoTerm.STRING || !"-160809".equals(((IStrategoString)arg966).stringValue()))
                  break Fail468;
                b_251 = term.getSubterm(1);
                term = termFactory.makeTuple(j_330, b_251);
                term = geq$S_0_0.instance.invoke(context, term);
                if(term == null)
                  break Fail468;
                term = Simplify.constFalse0;
                if(true)
                  break Success341;
              }
              term = term553;
              IStrategoTerm term554 = term;
              Success342:
              { 
                Fail469:
                { 
                  IStrategoTerm w_250 = null;
                  if(term.getTermType() != IStrategoTerm.TUPLE || term.getSubtermCount() != 2)
                    break Fail469;
                  IStrategoTerm arg967 = term.getSubterm(0);
                  if(arg967.getTermType() != IStrategoTerm.STRING || !"-343935".equals(((IStrategoString)arg967).stringValue()))
                    break Fail469;
                  w_250 = term.getSubterm(1);
                  term = termFactory.makeTuple(j_330, w_250);
                  term = gt$S_0_0.instance.invoke(context, term);
                  if(term == null)
                    break Fail469;
                  term = Simplify.constTrue0;
                  if(true)
                    break Success342;
                }
                term = term554;
                IStrategoTerm term555 = term;
                Success343:
                { 
                  Fail470:
                  { 
                    IStrategoTerm r_250 = null;
                    if(term.getTermType() != IStrategoTerm.TUPLE || term.getSubtermCount() != 2)
                      break Fail470;
                    IStrategoTerm arg968 = term.getSubterm(0);
                    if(arg968.getTermType() != IStrategoTerm.STRING || !"167662".equals(((IStrategoString)arg968).stringValue()))
                      break Fail470;
                    r_250 = term.getSubterm(1);
                    term = termFactory.makeTuple(j_330, r_250);
                    term = geq$S_0_0.instance.invoke(context, term);
                    if(term == null)
                      break Fail470;
                    term = Simplify.constTrue0;
                    if(true)
                      break Success343;
                  }
                  term = term555;
                  IStrategoTerm k_250 = null;
                  if(term.getTermType() != IStrategoTerm.TUPLE || term.getSubtermCount() != 2)
                    break Fail465;
                  IStrategoTerm arg969 = term.getSubterm(0);
                  if(arg969.getTermType() != IStrategoTerm.STRING || !"-177112".equals(((IStrategoString)arg969).stringValue()))
                    break Fail465;
                  k_250 = term.getSubterm(1);
                  term = termFactory.makeTuple(j_330, k_250);
                  term = gt$S_0_0.instance.invoke(context, term);
                  if(term == null)
                    break Fail465;
                  term = Simplify.constTrue0;
                }
              }
            }
          }
        }
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class aux_$Assertion2_0_3 extends Strategy 
  { 
    public static aux_$Assertion2_0_3 instance = new aux_$Assertion2_0_3();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term, IStrategoTerm t_330, IStrategoTerm u_330, IStrategoTerm v_330)
    { 
      ITermFactory termFactory = context.getFactory();
      context.push("aux_Assertion2_0_3");
      Fail471:
      { 
        IStrategoTerm term556 = term;
        Success344:
        { 
          Fail472:
          { 
            IStrategoTerm f_277 = null;
            if(term.getTermType() != IStrategoTerm.TUPLE || term.getSubtermCount() != 2)
              break Fail472;
            IStrategoTerm arg970 = term.getSubterm(0);
            if(arg970.getTermType() != IStrategoTerm.STRING || !"-719095".equals(((IStrategoString)arg970).stringValue()))
              break Fail472;
            f_277 = term.getSubterm(1);
            term = termFactory.makeTuple(u_330, f_277);
            term = geq$S_0_0.instance.invoke(context, term);
            if(term == null)
              break Fail472;
            term = Simplify.constFalse0;
            if(true)
              break Success344;
          }
          term = term556;
          IStrategoTerm term557 = term;
          Success345:
          { 
            Fail473:
            { 
              IStrategoTerm a_277 = null;
              if(term.getTermType() != IStrategoTerm.TUPLE || term.getSubtermCount() != 2)
                break Fail473;
              IStrategoTerm arg971 = term.getSubterm(0);
              if(arg971.getTermType() != IStrategoTerm.STRING || !"-636568".equals(((IStrategoString)arg971).stringValue()))
                break Fail473;
              a_277 = term.getSubterm(1);
              term = termFactory.makeTuple(u_330, a_277);
              term = geq$S_0_0.instance.invoke(context, term);
              if(term == null)
                break Fail473;
              term = Simplify.constFalse0;
              if(true)
                break Success345;
            }
            term = term557;
            IStrategoTerm term558 = term;
            Success346:
            { 
              Fail474:
              { 
                IStrategoTerm v_276 = null;
                if(term.getTermType() != IStrategoTerm.TUPLE || term.getSubtermCount() != 2)
                  break Fail474;
                IStrategoTerm arg972 = term.getSubterm(0);
                if(arg972.getTermType() != IStrategoTerm.STRING || !"-160230".equals(((IStrategoString)arg972).stringValue()))
                  break Fail474;
                v_276 = term.getSubterm(1);
                term = termFactory.makeTuple(u_330, v_276);
                term = geq$S_0_0.instance.invoke(context, term);
                if(term == null)
                  break Fail474;
                term = Simplify.constFalse0;
                if(true)
                  break Success346;
              }
              term = term558;
              IStrategoTerm term559 = term;
              Success347:
              { 
                Fail475:
                { 
                  IStrategoTerm q_276 = null;
                  if(term.getTermType() != IStrategoTerm.TUPLE || term.getSubtermCount() != 2)
                    break Fail475;
                  IStrategoTerm arg973 = term.getSubterm(0);
                  if(arg973.getTermType() != IStrategoTerm.STRING || !"-343357".equals(((IStrategoString)arg973).stringValue()))
                    break Fail475;
                  q_276 = term.getSubterm(1);
                  term = termFactory.makeTuple(u_330, q_276);
                  term = geq$S_0_0.instance.invoke(context, term);
                  if(term == null)
                    break Fail475;
                  term = Simplify.constTrue0;
                  if(true)
                    break Success347;
                }
                term = term559;
                IStrategoTerm term560 = term;
                Success348:
                { 
                  Fail476:
                  { 
                    IStrategoTerm l_276 = null;
                    if(term.getTermType() != IStrategoTerm.TUPLE || term.getSubtermCount() != 2)
                      break Fail476;
                    IStrategoTerm arg974 = term.getSubterm(0);
                    if(arg974.getTermType() != IStrategoTerm.STRING || !"168240".equals(((IStrategoString)arg974).stringValue()))
                      break Fail476;
                    l_276 = term.getSubterm(1);
                    term = termFactory.makeTuple(u_330, l_276);
                    term = geq$S_0_0.instance.invoke(context, term);
                    if(term == null)
                      break Fail476;
                    term = Simplify.constTrue0;
                    if(true)
                      break Success348;
                  }
                  term = term560;
                  IStrategoTerm g_276 = null;
                  if(term.getTermType() != IStrategoTerm.TUPLE || term.getSubtermCount() != 2)
                    break Fail471;
                  IStrategoTerm arg975 = term.getSubterm(0);
                  if(arg975.getTermType() != IStrategoTerm.STRING || !"-176534".equals(((IStrategoString)arg975).stringValue()))
                    break Fail471;
                  g_276 = term.getSubterm(1);
                  term = termFactory.makeTuple(u_330, g_276);
                  term = geq$S_0_0.instance.invoke(context, term);
                  if(term == null)
                    break Fail471;
                  term = Simplify.constTrue0;
                }
              }
            }
          }
        }
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class aux_$Assertion5_0_3 extends Strategy 
  { 
    public static aux_$Assertion5_0_3 instance = new aux_$Assertion5_0_3();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term, IStrategoTerm d_331, IStrategoTerm e_331, IStrategoTerm f_331)
    { 
      ITermFactory termFactory = context.getFactory();
      context.push("aux_Assertion5_0_3");
      Fail477:
      { 
        IStrategoTerm term561 = term;
        Success349:
        { 
          Fail478:
          { 
            IStrategoTerm w_286 = null;
            if(term.getTermType() != IStrategoTerm.TUPLE || term.getSubtermCount() != 2)
              break Fail478;
            IStrategoTerm arg976 = term.getSubterm(0);
            if(arg976.getTermType() != IStrategoTerm.STRING || !"-717360".equals(((IStrategoString)arg976).stringValue()))
              break Fail478;
            w_286 = term.getSubterm(1);
            term = termFactory.makeTuple(e_331, w_286);
            term = eq_0_0.instance.invoke(context, term);
            if(term == null)
              break Fail478;
            term = Simplify.constFalse0;
            if(true)
              break Success349;
          }
          term = term561;
          IStrategoTerm r_286 = null;
          if(term.getTermType() != IStrategoTerm.TUPLE || term.getSubtermCount() != 2)
            break Fail477;
          IStrategoTerm arg977 = term.getSubterm(0);
          if(arg977.getTermType() != IStrategoTerm.STRING || !"-341622".equals(((IStrategoString)arg977).stringValue()))
            break Fail477;
          r_286 = term.getSubterm(1);
          term = termFactory.makeTuple(e_331, r_286);
          term = eq_0_0.instance.invoke(context, term);
          if(term == null)
            break Fail477;
          term = Simplify.constTrue0;
        }
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class aux_$Assertion7_0_2 extends Strategy 
  { 
    public static aux_$Assertion7_0_2 instance = new aux_$Assertion7_0_2();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term, IStrategoTerm d_299, IStrategoTerm e_299)
    { 
      ITermFactory termFactory = context.getFactory();
      Fail479:
      { 
        IStrategoTerm f_299 = null;
        if(term.getTermType() != IStrategoTerm.TUPLE || term.getSubtermCount() != 2)
          break Fail479;
        IStrategoTerm arg978 = term.getSubterm(0);
        if(arg978.getTermType() != IStrategoTerm.STRING || !"-36342".equals(((IStrategoString)arg978).stringValue()))
          break Fail479;
        f_299 = term.getSubterm(1);
        term = termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{f_299});
        if(true)
          return term;
      }
      context.push("aux_Assertion7_0_2");
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class aux_$Assertion6_0_3 extends Strategy 
  { 
    public static aux_$Assertion6_0_3 instance = new aux_$Assertion6_0_3();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term, IStrategoTerm r_331, IStrategoTerm s_331, IStrategoTerm t_331)
    { 
      ITermFactory termFactory = context.getFactory();
      context.push("aux_Assertion6_0_3");
      Fail480:
      { 
        IStrategoTerm term562 = term;
        Success350:
        { 
          Fail481:
          { 
            IStrategoTerm j_323 = null;
            if(term.getTermType() != IStrategoTerm.TUPLE || term.getSubtermCount() != 2)
              break Fail481;
            IStrategoTerm arg979 = term.getSubterm(0);
            if(arg979.getTermType() != IStrategoTerm.STRING || !"-298364".equals(((IStrategoString)arg979).stringValue()))
              break Fail481;
            j_323 = term.getSubterm(1);
            term = termFactory.makeTuple(j_323, s_331);
            term = compare_1_0.instance.invoke(context, term, eq_0_0.instance);
            if(term == null)
              break Fail481;
            if(true)
              break Success350;
          }
          term = term562;
          IStrategoTerm term563 = term;
          Success351:
          { 
            Fail482:
            { 
              IStrategoTerm a_323 = null;
              if(term.getTermType() != IStrategoTerm.TUPLE || term.getSubtermCount() != 2)
                break Fail482;
              IStrategoTerm arg980 = term.getSubterm(0);
              if(arg980.getTermType() != IStrategoTerm.STRING || !"-215837".equals(((IStrategoString)arg980).stringValue()))
                break Fail482;
              a_323 = term.getSubterm(1);
              term = termFactory.makeTuple(a_323, s_331);
              term = compare_1_0.instance.invoke(context, term, geq$S_0_0.instance);
              if(term == null)
                break Fail482;
              if(true)
                break Success351;
            }
            term = term563;
            IStrategoTerm term564 = term;
            Success352:
            { 
              Fail483:
              { 
                IStrategoTerm s_322 = null;
                if(term.getTermType() != IStrategoTerm.TUPLE || term.getSubtermCount() != 2)
                  break Fail483;
                IStrategoTerm arg981 = term.getSubterm(0);
                if(arg981.getTermType() != IStrategoTerm.STRING || !"-142578".equals(((IStrategoString)arg981).stringValue()))
                  break Fail483;
                s_322 = term.getSubterm(1);
                term = termFactory.makeTuple(s_322, s_331);
                term = compare_1_0.instance.invoke(context, term, gt$S_0_0.instance);
                if(term == null)
                  break Fail483;
                if(true)
                  break Success352;
              }
              term = term564;
              IStrategoTerm term565 = term;
              Success353:
              { 
                Fail484:
                { 
                  IStrategoTerm n_322 = null;
                  if(term.getTermType() != IStrategoTerm.TUPLE || term.getSubtermCount() != 2)
                    break Fail484;
                  IStrategoTerm arg982 = term.getSubterm(0);
                  if(arg982.getTermType() != IStrategoTerm.STRING || !"-80979".equals(((IStrategoString)arg982).stringValue()))
                    break Fail484;
                  n_322 = term.getSubterm(1);
                  term = termFactory.makeTuple(n_322, s_331);
                  term = compare_1_0.instance.invoke(context, term, lifted284.instance);
                  if(term == null)
                    break Fail484;
                  if(true)
                    break Success353;
                }
                term = term565;
                IStrategoTerm term567 = term;
                Success354:
                { 
                  Fail485:
                  { 
                    IStrategoTerm i_322 = null;
                    if(term.getTermType() != IStrategoTerm.TUPLE || term.getSubtermCount() != 2)
                      break Fail485;
                    IStrategoTerm arg983 = term.getSubterm(0);
                    if(arg983.getTermType() != IStrategoTerm.STRING || !"-394164".equals(((IStrategoString)arg983).stringValue()))
                      break Fail485;
                    i_322 = term.getSubterm(1);
                    term = termFactory.makeTuple(i_322, s_331);
                    term = compare_1_0.instance.invoke(context, term, leq$S_0_0.instance);
                    if(term == null)
                      break Fail485;
                    if(true)
                      break Success354;
                  }
                  term = term567;
                  IStrategoTerm c_322 = null;
                  if(term.getTermType() != IStrategoTerm.TUPLE || term.getSubtermCount() != 2)
                    break Fail480;
                  IStrategoTerm arg984 = term.getSubterm(0);
                  if(arg984.getTermType() != IStrategoTerm.STRING || !"10393".equals(((IStrategoString)arg984).stringValue()))
                    break Fail480;
                  c_322 = term.getSubterm(1);
                  term = termFactory.makeTuple(c_322, s_331);
                  term = compare_1_0.instance.invoke(context, term, lt$S_0_0.instance);
                  if(term == null)
                    break Fail480;
                }
              }
            }
          }
        }
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class $Propagate$Constant_0_0 extends Strategy 
  { 
    public static $Propagate$Constant_0_0 instance = new $Propagate$Constant_0_0();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      ITermFactory termFactory = context.getFactory();
      context.push("PropagateConstant_0_0");
      Fail486:
      { 
        TermReference v_328 = new TermReference();
        TermReference w_328 = new TermReference();
        IStrategoTerm z_328 = null;
        IStrategoTerm b_329 = null;
        IStrategoTerm c_329 = null;
        if(v_328.value == null)
          v_328.value = term;
        else
          if(v_328.value != term && !v_328.value.match(term))
            break Fail486;
        if(term.getTermType() != IStrategoTerm.APPL || Simplify._consVar_1 != ((IStrategoAppl)term).getConstructor())
          break Fail486;
        if(w_328.value == null)
          w_328.value = term.getSubterm(0);
        else
          if(w_328.value != term.getSubterm(0) && !w_328.value.match(term.getSubterm(0)))
            break Fail486;
        b_329 = term;
        z_328 = Simplify.const116;
        term = b_329;
        c_329 = b_329;
        if(w_328.value == null)
          break Fail486;
        term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consVar_1, new IStrategoTerm[]{w_328.value}), checkListAnnos(termFactory, Simplify.constCons16));
        term = dr_lookup_rule_0_2.instance.invoke(context, c_329, z_328, term);
        if(term == null)
          break Fail486;
        lifted287 lifted2870 = new lifted287();
        lifted2870.w_328 = w_328;
        lifted2870.v_328 = v_328;
        term = fetch_elem_1_0.instance.invoke(context, term, lifted2870);
        if(term == null)
          break Fail486;
        context.popOnSuccess();
        if(true)
          return term;
      }
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") public static class aux_$Propagate$Constant_0_2 extends Strategy 
  { 
    public static aux_$Propagate$Constant_0_2 instance = new aux_$Propagate$Constant_0_2();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term, IStrategoTerm d_329, IStrategoTerm e_329)
    { 
      Fail487:
      { 
        IStrategoTerm f_329 = null;
        if(term.getTermType() != IStrategoTerm.TUPLE || term.getSubtermCount() != 2)
          break Fail487;
        IStrategoTerm arg985 = term.getSubterm(0);
        if(arg985.getTermType() != IStrategoTerm.STRING || !"-615148".equals(((IStrategoString)arg985).stringValue()))
          break Fail487;
        f_329 = term.getSubterm(1);
        term = f_329;
        if(true)
          return term;
      }
      context.push("aux_PropagateConstant_0_2");
      context.popOnFailure();
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted287 extends Strategy 
  { 
    TermReference w_328;

    TermReference v_328;

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail488:
      { 
        term = aux_$Propagate$Constant_0_2.instance.invoke(context, term, w_328.value, v_328.value);
        if(term == null)
          break Fail488;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted284 extends Strategy 
  { 
    public static final lifted284 instance = new lifted284();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail489:
      { 
        IStrategoTerm term566 = term;
        Success355:
        { 
          Fail490:
          { 
            term = eq_0_0.instance.invoke(context, term);
            if(term == null)
              break Fail490;
            { 
              if(true)
                break Fail489;
              if(true)
                break Success355;
            }
          }
          term = term566;
        }
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted280 extends Strategy 
  { 
    TermReference m_170;

    TermReference k_170;

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail491:
      { 
        term = aux_$Used$In$Assertion_0_2.instance.invoke(context, term, m_170.value, k_170.value);
        if(term == null)
          break Fail491;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted279 extends Strategy 
  { 
    TermReference v_166;

    TermReference t_166;

    TermReference u_166;

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail492:
      { 
        term = aux_$Assertion1_0_3.instance.invoke(context, term, v_166.value, t_166.value, u_166.value);
        if(term == null)
          break Fail492;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted278 extends Strategy 
  { 
    TermReference e_167;

    TermReference c_167;

    TermReference d_167;

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail493:
      { 
        term = aux_$Assertion1_0_3.instance.invoke(context, term, e_167.value, c_167.value, d_167.value);
        if(term == null)
          break Fail493;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted277 extends Strategy 
  { 
    TermReference o_167;

    TermReference m_167;

    TermReference n_167;

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail494:
      { 
        term = aux_$Assertion1_0_3.instance.invoke(context, term, o_167.value, m_167.value, n_167.value);
        if(term == null)
          break Fail494;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted276 extends Strategy 
  { 
    TermReference y_167;

    TermReference w_167;

    TermReference x_167;

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail495:
      { 
        term = aux_$Assertion1_0_3.instance.invoke(context, term, y_167.value, w_167.value, x_167.value);
        if(term == null)
          break Fail495;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted275 extends Strategy 
  { 
    TermReference h_168;

    TermReference f_168;

    TermReference g_168;

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail496:
      { 
        term = aux_$Assertion1_0_3.instance.invoke(context, term, h_168.value, f_168.value, g_168.value);
        if(term == null)
          break Fail496;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted274 extends Strategy 
  { 
    TermReference q_168;

    TermReference o_168;

    TermReference p_168;

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail497:
      { 
        term = aux_$Assertion1_0_3.instance.invoke(context, term, q_168.value, o_168.value, p_168.value);
        if(term == null)
          break Fail497;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted273 extends Strategy 
  { 
    TermReference c_151;

    TermReference y_150;

    TermReference z_150;

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail498:
      { 
        term = aux_$Assertion2_0_3.instance.invoke(context, term, c_151.value, y_150.value, z_150.value);
        if(term == null)
          break Fail498;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted272 extends Strategy 
  { 
    TermReference m_151;

    TermReference k_151;

    TermReference l_151;

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail499:
      { 
        term = aux_$Assertion2_0_3.instance.invoke(context, term, m_151.value, k_151.value, l_151.value);
        if(term == null)
          break Fail499;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted271 extends Strategy 
  { 
    TermReference g_152;

    TermReference y_151;

    TermReference d_152;

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail500:
      { 
        term = aux_$Assertion2_0_3.instance.invoke(context, term, g_152.value, y_151.value, d_152.value);
        if(term == null)
          break Fail500;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted270 extends Strategy 
  { 
    TermReference j_153;

    TermReference u_152;

    TermReference y_152;

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail501:
      { 
        term = aux_$Assertion2_0_3.instance.invoke(context, term, j_153.value, u_152.value, y_152.value);
        if(term == null)
          break Fail501;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted269 extends Strategy 
  { 
    TermReference b_154;

    TermReference z_153;

    TermReference a_154;

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail502:
      { 
        term = aux_$Assertion2_0_3.instance.invoke(context, term, b_154.value, z_153.value, a_154.value);
        if(term == null)
          break Fail502;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted268 extends Strategy 
  { 
    TermReference q_154;

    TermReference o_154;

    TermReference p_154;

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail503:
      { 
        term = aux_$Assertion2_0_3.instance.invoke(context, term, q_154.value, o_154.value, p_154.value);
        if(term == null)
          break Fail503;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted267 extends Strategy 
  { 
    TermReference f_137;

    TermReference d_137;

    TermReference e_137;

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail504:
      { 
        term = aux_$Assertion3_0_3.instance.invoke(context, term, f_137.value, d_137.value, e_137.value);
        if(term == null)
          break Fail504;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted266 extends Strategy 
  { 
    TermReference o_137;

    TermReference m_137;

    TermReference n_137;

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail505:
      { 
        term = aux_$Assertion3_0_3.instance.invoke(context, term, o_137.value, m_137.value, n_137.value);
        if(term == null)
          break Fail505;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted265 extends Strategy 
  { 
    TermReference a_138;

    TermReference v_137;

    TermReference z_137;

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail506:
      { 
        term = aux_$Assertion3_0_3.instance.invoke(context, term, a_138.value, v_137.value, z_137.value);
        if(term == null)
          break Fail506;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted264 extends Strategy 
  { 
    TermReference j_138;

    TermReference h_138;

    TermReference i_138;

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail507:
      { 
        term = aux_$Assertion3_0_3.instance.invoke(context, term, j_138.value, h_138.value, i_138.value);
        if(term == null)
          break Fail507;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted263 extends Strategy 
  { 
    TermReference v_138;

    TermReference t_138;

    TermReference u_138;

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail508:
      { 
        term = aux_$Assertion3_0_3.instance.invoke(context, term, v_138.value, t_138.value, u_138.value);
        if(term == null)
          break Fail508;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted262 extends Strategy 
  { 
    TermReference e_139;

    TermReference c_139;

    TermReference d_139;

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail509:
      { 
        term = aux_$Assertion3_0_3.instance.invoke(context, term, e_139.value, c_139.value, d_139.value);
        if(term == null)
          break Fail509;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted261 extends Strategy 
  { 
    TermReference v_122;

    TermReference t_122;

    TermReference u_122;

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail510:
      { 
        term = aux_$Assertion4_0_3.instance.invoke(context, term, v_122.value, t_122.value, u_122.value);
        if(term == null)
          break Fail510;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted260 extends Strategy 
  { 
    TermReference e_123;

    TermReference c_123;

    TermReference d_123;

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail511:
      { 
        term = aux_$Assertion4_0_3.instance.invoke(context, term, e_123.value, c_123.value, d_123.value);
        if(term == null)
          break Fail511;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted259 extends Strategy 
  { 
    TermReference n_123;

    TermReference l_123;

    TermReference m_123;

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail512:
      { 
        term = aux_$Assertion4_0_3.instance.invoke(context, term, n_123.value, l_123.value, m_123.value);
        if(term == null)
          break Fail512;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted258 extends Strategy 
  { 
    TermReference w_123;

    TermReference u_123;

    TermReference v_123;

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail513:
      { 
        term = aux_$Assertion4_0_3.instance.invoke(context, term, w_123.value, u_123.value, v_123.value);
        if(term == null)
          break Fail513;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted257 extends Strategy 
  { 
    TermReference m_124;

    TermReference f_124;

    TermReference i_124;

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail514:
      { 
        term = aux_$Assertion4_0_3.instance.invoke(context, term, m_124.value, f_124.value, i_124.value);
        if(term == null)
          break Fail514;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted256 extends Strategy 
  { 
    TermReference w_124;

    TermReference u_124;

    TermReference v_124;

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail515:
      { 
        term = aux_$Assertion4_0_3.instance.invoke(context, term, w_124.value, u_124.value, v_124.value);
        if(term == null)
          break Fail515;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted255 extends Strategy 
  { 
    TermReference i_113;

    TermReference f_113;

    TermReference h_113;

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail516:
      { 
        term = aux_$Assertion5_0_3.instance.invoke(context, term, i_113.value, f_113.value, h_113.value);
        if(term == null)
          break Fail516;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted254 extends Strategy 
  { 
    TermReference s_113;

    TermReference q_113;

    TermReference r_113;

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail517:
      { 
        term = aux_$Assertion5_0_3.instance.invoke(context, term, s_113.value, q_113.value, r_113.value);
        if(term == null)
          break Fail517;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted253 extends Strategy 
  { 
    TermReference r_107;

    TermReference p_107;

    TermReference q_107;

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail518:
      { 
        term = aux_$Assertion6_0_3.instance.invoke(context, term, r_107.value, p_107.value, q_107.value);
        if(term == null)
          break Fail518;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted252 extends Strategy 
  { 
    TermReference a_108;

    TermReference y_107;

    TermReference z_107;

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail519:
      { 
        term = aux_$Assertion6_0_3.instance.invoke(context, term, a_108.value, y_107.value, z_107.value);
        if(term == null)
          break Fail519;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted251 extends Strategy 
  { 
    TermReference j_108;

    TermReference h_108;

    TermReference i_108;

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail520:
      { 
        term = aux_$Assertion6_0_3.instance.invoke(context, term, j_108.value, h_108.value, i_108.value);
        if(term == null)
          break Fail520;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted250 extends Strategy 
  { 
    TermReference s_108;

    TermReference q_108;

    TermReference r_108;

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail521:
      { 
        term = aux_$Assertion6_0_3.instance.invoke(context, term, s_108.value, q_108.value, r_108.value);
        if(term == null)
          break Fail521;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted249 extends Strategy 
  { 
    TermReference b_109;

    TermReference z_108;

    TermReference a_109;

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail522:
      { 
        term = aux_$Assertion6_0_3.instance.invoke(context, term, b_109.value, z_108.value, a_109.value);
        if(term == null)
          break Fail522;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted248 extends Strategy 
  { 
    TermReference l_109;

    TermReference i_109;

    TermReference k_109;

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail523:
      { 
        term = aux_$Assertion6_0_3.instance.invoke(context, term, l_109.value, i_109.value, k_109.value);
        if(term == null)
          break Fail523;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted247 extends Strategy 
  { 
    TermReference a_99;

    TermReference b_99;

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail524:
      { 
        term = aux_$Assertion7_0_2.instance.invoke(context, term, a_99.value, b_99.value);
        if(term == null)
          break Fail524;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted234 extends Strategy 
  { 
    public static final lifted234 instance = new lifted234();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail525:
      { 
        IStrategoTerm b_83 = null;
        b_83 = term;
        term = dr_scope_1_1.instance.invoke(context, b_83, lifted235.instance, Simplify.const62);
        if(term == null)
          break Fail525;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted235 extends Strategy 
  { 
    public static final lifted235 instance = new lifted235();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail526:
      { 
        IStrategoTerm d_83 = null;
        d_83 = term;
        term = dr_scope_1_1.instance.invoke(context, d_83, lifted236.instance, Simplify.const55);
        if(term == null)
          break Fail526;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted236 extends Strategy 
  { 
    public static final lifted236 instance = new lifted236();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail527:
      { 
        IStrategoTerm f_83 = null;
        f_83 = term;
        term = dr_scope_1_1.instance.invoke(context, f_83, lifted237.instance, Simplify.const57);
        if(term == null)
          break Fail527;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted237 extends Strategy 
  { 
    public static final lifted237 instance = new lifted237();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail528:
      { 
        IStrategoTerm k_83 = null;
        k_83 = term;
        term = dr_scope_1_1.instance.invoke(context, k_83, lifted238.instance, Simplify.const58);
        if(term == null)
          break Fail528;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted238 extends Strategy 
  { 
    public static final lifted238 instance = new lifted238();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail529:
      { 
        IStrategoTerm m_83 = null;
        m_83 = term;
        term = dr_scope_1_1.instance.invoke(context, m_83, lifted239.instance, Simplify.const59);
        if(term == null)
          break Fail529;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted239 extends Strategy 
  { 
    public static final lifted239 instance = new lifted239();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail530:
      { 
        IStrategoTerm q_83 = null;
        q_83 = term;
        term = dr_scope_1_1.instance.invoke(context, q_83, lifted240.instance, Simplify.const60);
        if(term == null)
          break Fail530;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted240 extends Strategy 
  { 
    public static final lifted240 instance = new lifted240();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail531:
      { 
        IStrategoTerm t_83 = null;
        t_83 = term;
        term = dr_scope_1_1.instance.invoke(context, t_83, lifted241.instance, Simplify.const61);
        if(term == null)
          break Fail531;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted241 extends Strategy 
  { 
    public static final lifted241 instance = new lifted241();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail532:
      { 
        term = $Procedure_5_0.instance.invoke(context, term, _Id.instance, _Id.instance, propagate_constant_0_0.instance, propagate_constant_0_0.instance, _Id.instance);
        if(term == null)
          break Fail532;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted225 extends Strategy 
  { 
    public static final lifted225 instance = new lifted225();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail533:
      { 
        term = $C$For_4_0.instance.invoke(context, term, _Id.instance, propagate_constant_0_0.instance, _Id.instance, propagate_constant_0_0.instance);
        if(term == null)
          break Fail533;
        term = $C$For_4_0.instance.invoke(context, term, _Id.instance, _Id.instance, propagate_constant_0_0.instance, _Id.instance);
        if(term == null)
          break Fail533;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted212 extends Strategy 
  { 
    TermReference x_81;

    TermReference y_81;

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail534:
      { 
        lifted216 lifted2160 = new lifted216();
        lifted213 lifted2130 = new lifted213();
        lifted2160.y_81 = y_81;
        lifted2130.x_81 = x_81;
        term = $For_4_0.instance.invoke(context, term, lifted2130, _Id.instance, _Id.instance, lifted2160);
        if(term == null)
          break Fail534;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted216 extends Strategy 
  { 
    TermReference y_81;

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      ITermFactory termFactory = context.getFactory();
      Fail535:
      { 
        IStrategoTerm e_82 = null;
        e_82 = term;
        if(y_81.value == null)
          break Fail535;
        term = (IStrategoTerm)termFactory.makeListCons(Simplify.const120, termFactory.makeListCons(y_81.value, (IStrategoList)Simplify.constNil0));
        term = debug_simplify_0_0.instance.invoke(context, term);
        if(term == null)
          break Fail535;
        term = propagate_constant_0_0.instance.invoke(context, e_82);
        if(term == null)
          break Fail535;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted213 extends Strategy 
  { 
    TermReference x_81;

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      ITermFactory termFactory = context.getFactory();
      Fail536:
      { 
        IStrategoTerm c_82 = null;
        IStrategoTerm m_82 = null;
        IStrategoTerm o_82 = null;
        IStrategoTerm p_82 = null;
        IStrategoTerm d_82 = null;
        if(term.getTermType() != IStrategoTerm.APPL || Simplify._consVar_1 != ((IStrategoAppl)term).getConstructor())
          break Fail536;
        if(x_81.value == null)
          x_81.value = term.getSubterm(0);
        else
          if(x_81.value != term.getSubterm(0) && !x_81.value.match(term.getSubterm(0)))
            break Fail536;
        c_82 = term;
        o_82 = term;
        m_82 = Simplify.const116;
        term = o_82;
        p_82 = o_82;
        if(x_81.value == null)
          break Fail536;
        term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consVar_1, new IStrategoTerm[]{x_81.value}), checkListAnnos(termFactory, Simplify.constCons16));
        term = dr_undefine_rule_0_2.instance.invoke(context, p_82, m_82, term);
        if(term == null)
          break Fail536;
        term = c_82;
        d_82 = c_82;
        if(x_81.value == null)
          break Fail536;
        term = termFactory.makeAppl(Simplify._consVar_1, new IStrategoTerm[]{x_81.value});
        term = undefine_assertions_0_0.instance.invoke(context, term);
        if(term == null)
          break Fail536;
        term = d_82;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted204 extends Strategy 
  { 
    TermReference x_81;

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      ITermFactory termFactory = context.getFactory();
      Fail537:
      { 
        IStrategoTerm z_81 = null;
        IStrategoTerm g_82 = null;
        IStrategoTerm i_82 = null;
        IStrategoTerm j_82 = null;
        IStrategoTerm a_82 = null;
        if(term.getTermType() != IStrategoTerm.APPL || Simplify._consVar_1 != ((IStrategoAppl)term).getConstructor())
          break Fail537;
        if(x_81.value == null)
          x_81.value = term.getSubterm(0);
        else
          if(x_81.value != term.getSubterm(0) && !x_81.value.match(term.getSubterm(0)))
            break Fail537;
        z_81 = term;
        i_82 = term;
        g_82 = Simplify.const116;
        term = i_82;
        j_82 = i_82;
        if(x_81.value == null)
          break Fail537;
        term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consVar_1, new IStrategoTerm[]{x_81.value}), checkListAnnos(termFactory, Simplify.constCons16));
        term = dr_undefine_rule_0_2.instance.invoke(context, j_82, g_82, term);
        if(term == null)
          break Fail537;
        term = z_81;
        a_82 = z_81;
        if(x_81.value == null)
          break Fail537;
        term = termFactory.makeAppl(Simplify._consVar_1, new IStrategoTerm[]{x_81.value});
        term = undefine_assertions_0_0.instance.invoke(context, term);
        if(term == null)
          break Fail537;
        term = a_82;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted201 extends Strategy 
  { 
    public static final lifted201 instance = new lifted201();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail538:
      { 
        term = $While_2_0.instance.invoke(context, term, propagate_constant_0_0.instance, propagate_constant_0_0.instance);
        if(term == null)
          break Fail538;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted190 extends Strategy 
  { 
    public static final lifted190 instance = new lifted190();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail539:
      { 
        term = $If$Else$Exp_3_0.instance.invoke(context, term, _Id.instance, _Id.instance, propagate_constant_0_0.instance);
        if(term == null)
          break Fail539;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted186 extends Strategy 
  { 
    public static final lifted186 instance = new lifted186();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail540:
      { 
        term = $If$Else$Exp_3_0.instance.invoke(context, term, _Id.instance, propagate_constant_0_0.instance, _Id.instance);
        if(term == null)
          break Fail540;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted182 extends Strategy 
  { 
    public static final lifted182 instance = new lifted182();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail541:
      { 
        term = try_1_0.instance.invoke(context, term, propagate_constant_0_0.instance);
        if(term == null)
          break Fail541;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted178 extends Strategy 
  { 
    public static final lifted178 instance = new lifted178();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail542:
      { 
        term = $If$Else_3_0.instance.invoke(context, term, _Id.instance, _Id.instance, propagate_constant_0_0.instance);
        if(term == null)
          break Fail542;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted174 extends Strategy 
  { 
    public static final lifted174 instance = new lifted174();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail543:
      { 
        term = $If$Else_3_0.instance.invoke(context, term, _Id.instance, propagate_constant_0_0.instance, _Id.instance);
        if(term == null)
          break Fail543;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted167 extends Strategy 
  { 
    public static final lifted167 instance = new lifted167();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail544:
      { 
        term = $If_2_0.instance.invoke(context, term, _Id.instance, propagate_constant_0_0.instance);
        if(term == null)
          break Fail544;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted164 extends Strategy 
  { 
    TermReference o_80;

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail545:
      { 
        term = propagate_constant_0_0.instance.invoke(context, term);
        if(term == null)
          break Fail545;
        if(o_80.value == null)
          o_80.value = term;
        else
          if(o_80.value != term && !o_80.value.match(term))
            break Fail545;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted162 extends Strategy 
  { 
    TermReference p_80;

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail546:
      { 
        lifted163 lifted1630 = new lifted163();
        lifted1630.p_80 = p_80;
        term = $Var_1_0.instance.invoke(context, term, lifted1630);
        if(term == null)
          break Fail546;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted163 extends Strategy 
  { 
    TermReference p_80;

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail547:
      { 
        if(p_80.value == null)
          p_80.value = term;
        else
          if(p_80.value != term && !p_80.value.match(term))
            break Fail547;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted158 extends Strategy 
  { 
    TermReference j_79;

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail548:
      { 
        term = propagate_constant_0_0.instance.invoke(context, term);
        if(term == null)
          break Fail548;
        if(j_79.value == null)
          j_79.value = term;
        else
          if(j_79.value != term && !j_79.value.match(term))
            break Fail548;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted156 extends Strategy 
  { 
    TermReference m_79;

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail549:
      { 
        lifted157 lifted1570 = new lifted157();
        lifted1570.m_79 = m_79;
        term = $Var_1_0.instance.invoke(context, term, lifted1570);
        if(term == null)
          break Fail549;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted157 extends Strategy 
  { 
    TermReference m_79;

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail550:
      { 
        if(m_79.value == null)
          m_79.value = term;
        else
          if(m_79.value != term && !m_79.value.match(term))
            break Fail550;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted151 extends Strategy 
  { 
    public static final lifted151 instance = new lifted151();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail551:
      { 
        term = try_1_0.instance.invoke(context, term, $Remove$Duplicate$Assertion_0_0.instance);
        if(term == null)
          break Fail551;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted149 extends Strategy 
  { 
    public static final lifted149 instance = new lifted149();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail552:
      { 
        term = try_1_0.instance.invoke(context, term, lifted150.instance);
        if(term == null)
          break Fail552;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted150 extends Strategy 
  { 
    public static final lifted150 instance = new lifted150();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail553:
      { 
        IStrategoTerm term476 = term;
        Success356:
        { 
          Fail554:
          { 
            term = $If$Assertion_0_0.instance.invoke(context, term);
            if(term == null)
              break Fail554;
            if(true)
              break Success356;
          }
          term = $For$Assertion_0_0.instance.invoke(context, term476);
          if(term == null)
            break Fail553;
        }
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted148 extends Strategy 
  { 
    public static final lifted148 instance = new lifted148();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail555:
      { 
        IStrategoTerm term452 = term;
        Success357:
        { 
          Fail556:
          { 
            term = eq_0_0.instance.invoke(context, term);
            if(term == null)
              break Fail556;
            { 
              if(true)
                break Fail555;
              if(true)
                break Success357;
            }
          }
          term = term452;
        }
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class y_483 extends Strategy 
  { 
    public static final y_483 instance = new y_483();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term, Strategy a_484)
    { 
      Fail557:
      { 
        lifted141 lifted1410 = new lifted141();
        lifted1410.a_484 = a_484;
        term = SRTS_all.instance.invoke(context, term, lifted1410);
        if(term == null)
          break Fail557;
        term = a_484.invoke(context, term);
        if(term == null)
          break Fail557;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted141 extends Strategy 
  { 
    Strategy a_484;

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail558:
      { 
        term = y_483.instance.invoke(context, term, a_484);
        if(term == null)
          break Fail558;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class n_482 extends Strategy 
  { 
    public static final n_482 instance = new n_482();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      ITermFactory termFactory = context.getFactory();
      Fail559:
      { 
        IStrategoTerm term278 = term;
        Success358:
        { 
          Fail560:
          { 
            IStrategoTerm term279 = term;
            IStrategoConstructor cons48 = term.getTermType() == IStrategoTerm.APPL ? ((IStrategoAppl)term).getConstructor() : null;
            Success359:
            { 
              if(cons48 == Simplify._consAdd_2)
              { 
                Fail561:
                { 
                  IStrategoTerm z_481 = null;
                  IStrategoTerm a_482 = null;
                  IStrategoTerm b_482 = null;
                  IStrategoTerm c_482 = null;
                  IStrategoTerm arg462 = term.getSubterm(0);
                  if(arg462.getTermType() != IStrategoTerm.APPL || Simplify._consMul_2 != ((IStrategoAppl)arg462).getConstructor())
                    break Fail561;
                  a_482 = arg462.getSubterm(0);
                  IStrategoTerm arg463 = arg462.getSubterm(1);
                  if(arg463.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg463).getConstructor())
                    break Fail561;
                  c_482 = arg463.getSubterm(0);
                  IStrategoTerm arg464 = term.getSubterm(1);
                  if(arg464.getTermType() != IStrategoTerm.APPL || Simplify._consMul_2 != ((IStrategoAppl)arg464).getConstructor())
                    break Fail561;
                  z_481 = arg464.getSubterm(0);
                  IStrategoTerm arg465 = arg464.getSubterm(1);
                  if(arg465.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg465).getConstructor())
                    break Fail561;
                  b_482 = arg465.getSubterm(0);
                  term = termFactory.makeTuple(b_482, c_482);
                  term = lt$S_0_0.instance.invoke(context, term);
                  if(term == null)
                    break Fail561;
                  term = termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{z_481, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{b_482})}), termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{a_482, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{c_482})})});
                  term = this.invoke(context, term);
                  if(term == null)
                    break Fail561;
                  if(true)
                    break Success359;
                }
                term = term279;
              }
              if(cons48 == Simplify._consAdd_2)
              { 
                IStrategoTerm e_482 = null;
                IStrategoTerm f_482 = null;
                IStrategoTerm g_482 = null;
                IStrategoTerm h_482 = null;
                IStrategoTerm i_482 = null;
                IStrategoTerm arg466 = term.getSubterm(0);
                if(arg466.getTermType() != IStrategoTerm.APPL || Simplify._consAdd_2 != ((IStrategoAppl)arg466).getConstructor())
                  break Fail560;
                e_482 = arg466.getSubterm(0);
                IStrategoTerm arg467 = arg466.getSubterm(1);
                if(arg467.getTermType() != IStrategoTerm.APPL || Simplify._consMul_2 != ((IStrategoAppl)arg467).getConstructor())
                  break Fail560;
                g_482 = arg467.getSubterm(0);
                IStrategoTerm arg468 = arg467.getSubterm(1);
                if(arg468.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg468).getConstructor())
                  break Fail560;
                i_482 = arg468.getSubterm(0);
                IStrategoTerm arg469 = term.getSubterm(1);
                if(arg469.getTermType() != IStrategoTerm.APPL || Simplify._consMul_2 != ((IStrategoAppl)arg469).getConstructor())
                  break Fail560;
                f_482 = arg469.getSubterm(0);
                IStrategoTerm arg470 = arg469.getSubterm(1);
                if(arg470.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg470).getConstructor())
                  break Fail560;
                h_482 = arg470.getSubterm(0);
                term = termFactory.makeTuple(h_482, i_482);
                term = lt$S_0_0.instance.invoke(context, term);
                if(term == null)
                  break Fail560;
                term = termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{e_482, termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{f_482, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{h_482})})});
                term = this.invoke(context, term);
                if(term == null)
                  break Fail560;
                term = termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{term, termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{g_482, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{i_482})})});
                term = this.invoke(context, term);
                if(term == null)
                  break Fail560;
              }
              else
              { 
                break Fail560;
              }
            }
            if(true)
              break Success358;
          }
          term = term278;
        }
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class m_482 extends Strategy 
  { 
    public static final m_482 instance = new m_482();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term, Strategy o_482)
    { 
      Fail562:
      { 
        lifted139 lifted1390 = new lifted139();
        lifted1390.o_482 = o_482;
        term = SRTS_all.instance.invoke(context, term, lifted1390);
        if(term == null)
          break Fail562;
        term = o_482.invoke(context, term);
        if(term == null)
          break Fail562;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted139 extends Strategy 
  { 
    Strategy o_482;

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail563:
      { 
        term = m_482.instance.invoke(context, term, o_482);
        if(term == null)
          break Fail563;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class j_481 extends Strategy 
  { 
    public static final j_481 instance = new j_481();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      ITermFactory termFactory = context.getFactory();
      Fail564:
      { 
        IStrategoTerm term277 = term;
        Success360:
        { 
          Fail565:
          { 
            IStrategoTerm c_481 = null;
            IStrategoTerm d_481 = null;
            IStrategoTerm e_481 = null;
            if(term.getTermType() != IStrategoTerm.APPL || Simplify._consMul_2 != ((IStrategoAppl)term).getConstructor())
              break Fail565;
            c_481 = term.getSubterm(0);
            IStrategoTerm arg461 = term.getSubterm(1);
            if(arg461.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg461).getConstructor())
              break Fail565;
            d_481 = arg461.getSubterm(0);
            term = termFactory.makeTuple(d_481, Simplify.const53);
            term = lt$S_0_0.instance.invoke(context, term);
            if(term == null)
              break Fail565;
            term = termFactory.makeTuple(Simplify.const53, d_481);
            term = subt$S_0_0.instance.invoke(context, term);
            if(term == null)
              break Fail565;
            e_481 = term;
            term = i_481.instance.invoke(context, e_481, this);
            if(term == null)
              break Fail565;
            term = termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consNeg_1, new IStrategoTerm[]{c_481}), termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{term})});
            term = this.invoke(context, term);
            if(term == null)
              break Fail565;
            if(true)
              break Success360;
          }
          term = term277;
        }
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class i_481 extends Strategy 
  { 
    public static final i_481 instance = new i_481();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term, Strategy k_481)
    { 
      Fail566:
      { 
        lifted138 lifted1380 = new lifted138();
        lifted1380.k_481 = k_481;
        term = SRTS_all.instance.invoke(context, term, lifted1380);
        if(term == null)
          break Fail566;
        term = k_481.invoke(context, term);
        if(term == null)
          break Fail566;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted138 extends Strategy 
  { 
    Strategy k_481;

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail567:
      { 
        term = i_481.instance.invoke(context, term, k_481);
        if(term == null)
          break Fail567;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class r_483 extends Strategy 
  { 
    public static final r_483 instance = new r_483();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      ITermFactory termFactory = context.getFactory();
      Fail568:
      { 
        IStrategoTerm term273 = term;
        Success361:
        { 
          Fail569:
          { 
            IStrategoTerm term274 = term;
            IStrategoConstructor cons50 = term.getTermType() == IStrategoTerm.APPL ? ((IStrategoAppl)term).getConstructor() : null;
            Success362:
            { 
              if(cons50 == Simplify._consAdd_2)
              { 
                Fail570:
                { 
                  IStrategoTerm d_483 = null;
                  IStrategoTerm e_483 = null;
                  IStrategoTerm f_483 = null;
                  IStrategoTerm arg452 = term.getSubterm(0);
                  if(arg452.getTermType() != IStrategoTerm.APPL || Simplify._consMul_2 != ((IStrategoAppl)arg452).getConstructor())
                    break Fail570;
                  d_483 = arg452.getSubterm(0);
                  IStrategoTerm arg453 = arg452.getSubterm(1);
                  if(arg453.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg453).getConstructor())
                    break Fail570;
                  f_483 = arg453.getSubterm(0);
                  IStrategoTerm arg454 = term.getSubterm(1);
                  if(arg454.getTermType() != IStrategoTerm.APPL || Simplify._consMul_2 != ((IStrategoAppl)arg454).getConstructor())
                    break Fail570;
                  e_483 = arg454.getSubterm(0);
                  IStrategoTerm arg455 = arg454.getSubterm(1);
                  if(arg455.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg455).getConstructor())
                    break Fail570;
                  if(arg455.getSubterm(0) != f_483 && !f_483.match(arg455.getSubterm(0)))
                    break Fail570;
                  term = f_483;
                  IStrategoTerm term275 = term;
                  Success363:
                  { 
                    Fail571:
                    { 
                      if(term.getTermType() != IStrategoTerm.STRING || !"1".equals(((IStrategoString)term).stringValue()))
                        break Fail571;
                      { 
                        if(true)
                          break Fail570;
                        if(true)
                          break Success363;
                      }
                    }
                    term = term275;
                  }
                  term = termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{d_483, e_483});
                  term = this.invoke(context, term);
                  if(term == null)
                    break Fail570;
                  term = termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{term, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{f_483})});
                  if(true)
                    break Success362;
                }
                term = term274;
              }
              if(cons50 == Simplify._consAdd_2)
              { 
                IStrategoTerm j_483 = null;
                IStrategoTerm k_483 = null;
                IStrategoTerm l_483 = null;
                IStrategoTerm m_483 = null;
                IStrategoTerm arg456 = term.getSubterm(0);
                if(arg456.getTermType() != IStrategoTerm.APPL || Simplify._consAdd_2 != ((IStrategoAppl)arg456).getConstructor())
                  break Fail569;
                j_483 = arg456.getSubterm(0);
                IStrategoTerm arg457 = arg456.getSubterm(1);
                if(arg457.getTermType() != IStrategoTerm.APPL || Simplify._consMul_2 != ((IStrategoAppl)arg457).getConstructor())
                  break Fail569;
                k_483 = arg457.getSubterm(0);
                IStrategoTerm arg458 = arg457.getSubterm(1);
                if(arg458.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg458).getConstructor())
                  break Fail569;
                m_483 = arg458.getSubterm(0);
                IStrategoTerm arg459 = term.getSubterm(1);
                if(arg459.getTermType() != IStrategoTerm.APPL || Simplify._consMul_2 != ((IStrategoAppl)arg459).getConstructor())
                  break Fail569;
                l_483 = arg459.getSubterm(0);
                IStrategoTerm arg460 = arg459.getSubterm(1);
                if(arg460.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg460).getConstructor())
                  break Fail569;
                if(arg460.getSubterm(0) != m_483 && !m_483.match(arg460.getSubterm(0)))
                  break Fail569;
                term = m_483;
                IStrategoTerm term276 = term;
                Success364:
                { 
                  Fail572:
                  { 
                    if(term.getTermType() != IStrategoTerm.STRING || !"1".equals(((IStrategoString)term).stringValue()))
                      break Fail572;
                    { 
                      if(true)
                        break Fail569;
                      if(true)
                        break Success364;
                    }
                  }
                  term = term276;
                }
                term = termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{k_483, l_483});
                term = this.invoke(context, term);
                if(term == null)
                  break Fail569;
                term = termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{j_483, termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{term, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{m_483})})});
                term = this.invoke(context, term);
                if(term == null)
                  break Fail569;
              }
              else
              { 
                break Fail569;
              }
            }
            if(true)
              break Success361;
          }
          term = term273;
        }
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class q_483 extends Strategy 
  { 
    public static final q_483 instance = new q_483();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term, Strategy s_483)
    { 
      Fail573:
      { 
        lifted140 lifted1400 = new lifted140();
        lifted1400.s_483 = s_483;
        term = SRTS_all.instance.invoke(context, term, lifted1400);
        if(term == null)
          break Fail573;
        term = s_483.invoke(context, term);
        if(term == null)
          break Fail573;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted140 extends Strategy 
  { 
    Strategy s_483;

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail574:
      { 
        term = q_483.instance.invoke(context, term, s_483);
        if(term == null)
          break Fail574;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class t_480 extends Strategy 
  { 
    Strategy t_480;

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail575:
      { 
        IStrategoTerm term110 = term;
        Success365:
        { 
          Fail576:
          { 
            canonical_0_0_fragment_4 canonical_0_0_fragment_40 = new canonical_0_0_fragment_4();
            canonical_0_0_fragment_40.t_480 = t_480;
            term = canonical_0_0_fragment_40.invoke(context, term);
            if(term == null)
              break Fail576;
            if(true)
              break Success365;
          }
          term = term110;
        }
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class canonical_0_0_fragment_4 extends Strategy 
  { 
    Strategy t_480;

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      ITermFactory termFactory = context.getFactory();
      Fail577:
      { 
        IStrategoTerm term111 = term;
        Success366:
        { 
          Fail578:
          { 
            IStrategoTerm term112 = term;
            IStrategoConstructor cons51 = term.getTermType() == IStrategoTerm.APPL ? ((IStrategoAppl)term).getConstructor() : null;
            Success367:
            { 
              if(cons51 == Simplify._consNot_1)
              { 
                Fail579:
                { 
                  IStrategoTerm q_452 = null;
                  IStrategoTerm r_452 = null;
                  IStrategoTerm s_452 = null;
                  IStrategoTerm arg106 = term.getSubterm(0);
                  if(arg106.getTermType() != IStrategoTerm.APPL || Simplify._consAnd_2 != ((IStrategoAppl)arg106).getConstructor())
                    break Fail579;
                  q_452 = arg106.getSubterm(0);
                  r_452 = arg106.getSubterm(1);
                  term = termFactory.makeAppl(Simplify._consNot_1, new IStrategoTerm[]{q_452});
                  term = t_480.invoke(context, term);
                  if(term == null)
                    break Fail579;
                  s_452 = term;
                  term = termFactory.makeAppl(Simplify._consNot_1, new IStrategoTerm[]{r_452});
                  term = t_480.invoke(context, term);
                  if(term == null)
                    break Fail579;
                  term = termFactory.makeAppl(Simplify._consOr_2, new IStrategoTerm[]{s_452, term});
                  term = t_480.invoke(context, term);
                  if(term == null)
                    break Fail579;
                  if(true)
                    break Success367;
                }
                term = term112;
              }
              Success368:
              { 
                if(cons51 == Simplify._consNot_1)
                { 
                  Fail580:
                  { 
                    IStrategoTerm w_452 = null;
                    IStrategoTerm x_452 = null;
                    IStrategoTerm y_452 = null;
                    IStrategoTerm arg107 = term.getSubterm(0);
                    if(arg107.getTermType() != IStrategoTerm.APPL || Simplify._consOr_2 != ((IStrategoAppl)arg107).getConstructor())
                      break Fail580;
                    w_452 = arg107.getSubterm(0);
                    x_452 = arg107.getSubterm(1);
                    term = termFactory.makeAppl(Simplify._consNot_1, new IStrategoTerm[]{w_452});
                    term = t_480.invoke(context, term);
                    if(term == null)
                      break Fail580;
                    y_452 = term;
                    term = termFactory.makeAppl(Simplify._consNot_1, new IStrategoTerm[]{x_452});
                    term = t_480.invoke(context, term);
                    if(term == null)
                      break Fail580;
                    term = termFactory.makeAppl(Simplify._consAnd_2, new IStrategoTerm[]{y_452, term});
                    term = t_480.invoke(context, term);
                    if(term == null)
                      break Fail580;
                    if(true)
                      break Success368;
                  }
                  term = term112;
                }
                Success369:
                { 
                  if(cons51 == Simplify._consNot_1)
                  { 
                    Fail581:
                    { 
                      IStrategoTerm c_453 = null;
                      IStrategoTerm d_453 = null;
                      IStrategoTerm arg108 = term.getSubterm(0);
                      if(arg108.getTermType() != IStrategoTerm.APPL || Simplify._consLt_2 != ((IStrategoAppl)arg108).getConstructor())
                        break Fail581;
                      c_453 = arg108.getSubterm(0);
                      d_453 = arg108.getSubterm(1);
                      term = termFactory.makeAppl(Simplify._consGeq_2, new IStrategoTerm[]{c_453, d_453});
                      term = t_480.invoke(context, term);
                      if(term == null)
                        break Fail581;
                      if(true)
                        break Success369;
                    }
                    term = term112;
                  }
                  Success370:
                  { 
                    if(cons51 == Simplify._consNot_1)
                    { 
                      Fail582:
                      { 
                        IStrategoTerm e_453 = null;
                        IStrategoTerm f_453 = null;
                        IStrategoTerm arg109 = term.getSubterm(0);
                        if(arg109.getTermType() != IStrategoTerm.APPL || Simplify._consLeq_2 != ((IStrategoAppl)arg109).getConstructor())
                          break Fail582;
                        e_453 = arg109.getSubterm(0);
                        f_453 = arg109.getSubterm(1);
                        term = termFactory.makeAppl(Simplify._consGt_2, new IStrategoTerm[]{e_453, f_453});
                        term = t_480.invoke(context, term);
                        if(term == null)
                          break Fail582;
                        if(true)
                          break Success370;
                      }
                      term = term112;
                    }
                    Success371:
                    { 
                      if(cons51 == Simplify._consNot_1)
                      { 
                        Fail583:
                        { 
                          IStrategoTerm g_453 = null;
                          IStrategoTerm h_453 = null;
                          IStrategoTerm arg110 = term.getSubterm(0);
                          if(arg110.getTermType() != IStrategoTerm.APPL || Simplify._consGt_2 != ((IStrategoAppl)arg110).getConstructor())
                            break Fail583;
                          g_453 = arg110.getSubterm(0);
                          h_453 = arg110.getSubterm(1);
                          term = termFactory.makeAppl(Simplify._consLeq_2, new IStrategoTerm[]{g_453, h_453});
                          term = t_480.invoke(context, term);
                          if(term == null)
                            break Fail583;
                          if(true)
                            break Success371;
                        }
                        term = term112;
                      }
                      Success372:
                      { 
                        if(cons51 == Simplify._consNot_1)
                        { 
                          Fail584:
                          { 
                            IStrategoTerm i_453 = null;
                            IStrategoTerm j_453 = null;
                            IStrategoTerm arg111 = term.getSubterm(0);
                            if(arg111.getTermType() != IStrategoTerm.APPL || Simplify._consGeq_2 != ((IStrategoAppl)arg111).getConstructor())
                              break Fail584;
                            i_453 = arg111.getSubterm(0);
                            j_453 = arg111.getSubterm(1);
                            term = termFactory.makeAppl(Simplify._consLt_2, new IStrategoTerm[]{i_453, j_453});
                            term = t_480.invoke(context, term);
                            if(term == null)
                              break Fail584;
                            if(true)
                              break Success372;
                          }
                          term = term112;
                        }
                        Success373:
                        { 
                          if(cons51 == Simplify._consNot_1)
                          { 
                            Fail585:
                            { 
                              IStrategoTerm k_453 = null;
                              IStrategoTerm l_453 = null;
                              IStrategoTerm arg112 = term.getSubterm(0);
                              if(arg112.getTermType() != IStrategoTerm.APPL || Simplify._consEqu_2 != ((IStrategoAppl)arg112).getConstructor())
                                break Fail585;
                              k_453 = arg112.getSubterm(0);
                              l_453 = arg112.getSubterm(1);
                              term = termFactory.makeAppl(Simplify._consNeq_2, new IStrategoTerm[]{k_453, l_453});
                              term = t_480.invoke(context, term);
                              if(term == null)
                                break Fail585;
                              if(true)
                                break Success373;
                            }
                            term = term112;
                          }
                          if(cons51 == Simplify._consNot_1)
                          { 
                            IStrategoTerm m_453 = null;
                            IStrategoTerm n_453 = null;
                            IStrategoTerm arg113 = term.getSubterm(0);
                            if(arg113.getTermType() != IStrategoTerm.APPL || Simplify._consNeq_2 != ((IStrategoAppl)arg113).getConstructor())
                              break Fail578;
                            m_453 = arg113.getSubterm(0);
                            n_453 = arg113.getSubterm(1);
                            term = termFactory.makeAppl(Simplify._consEqu_2, new IStrategoTerm[]{m_453, n_453});
                            term = t_480.invoke(context, term);
                            if(term == null)
                              break Fail578;
                          }
                          else
                          { 
                            break Fail578;
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
            if(true)
              break Success366;
          }
          term = term111;
          IStrategoTerm term119 = term;
          Success374:
          { 
            Fail586:
            { 
              IStrategoTerm term120 = term;
              IStrategoConstructor cons52 = term.getTermType() == IStrategoTerm.APPL ? ((IStrategoAppl)term).getConstructor() : null;
              Success375:
              { 
                if(cons52 == Simplify._consSub_2)
                { 
                  Fail587:
                  { 
                    IStrategoTerm o_453 = null;
                    IStrategoTerm p_453 = null;
                    o_453 = term.getSubterm(0);
                    p_453 = term.getSubterm(1);
                    term = termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{p_453, Simplify.constInt2});
                    term = t_480.invoke(context, term);
                    if(term == null)
                      break Fail587;
                    term = termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{o_453, term});
                    term = t_480.invoke(context, term);
                    if(term == null)
                      break Fail587;
                    if(true)
                      break Success375;
                  }
                  term = term120;
                }
                if(cons52 == Simplify._consNeg_1)
                { 
                  IStrategoTerm s_453 = null;
                  s_453 = term.getSubterm(0);
                  term = termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{s_453, Simplify.constInt2});
                  term = t_480.invoke(context, term);
                  if(term == null)
                    break Fail586;
                }
                else
                { 
                  break Fail586;
                }
              }
              if(true)
                break Success374;
            }
            term = term119;
            IStrategoTerm term121 = term;
            Success376:
            { 
              Fail588:
              { 
                IStrategoTerm term122 = term;
                IStrategoConstructor cons53 = term.getTermType() == IStrategoTerm.APPL ? ((IStrategoAppl)term).getConstructor() : null;
                Success377:
                { 
                  if(cons53 == Simplify._consAdd_2)
                  { 
                    Fail589:
                    { 
                      IStrategoTerm t_453 = null;
                      t_453 = term.getSubterm(0);
                      IStrategoTerm arg114 = term.getSubterm(1);
                      if(arg114.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg114).getConstructor())
                        break Fail589;
                      IStrategoTerm arg115 = arg114.getSubterm(0);
                      if(arg115.getTermType() != IStrategoTerm.STRING || !"0".equals(((IStrategoString)arg115).stringValue()))
                        break Fail589;
                      term = t_453;
                      if(true)
                        break Success377;
                    }
                    term = term122;
                  }
                  if(cons53 == Simplify._consAdd_2)
                  { 
                    IStrategoTerm u_453 = null;
                    IStrategoTerm arg116 = term.getSubterm(0);
                    if(arg116.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg116).getConstructor())
                      break Fail588;
                    IStrategoTerm arg117 = arg116.getSubterm(0);
                    if(arg117.getTermType() != IStrategoTerm.STRING || !"0".equals(((IStrategoString)arg117).stringValue()))
                      break Fail588;
                    u_453 = term.getSubterm(1);
                    term = u_453;
                  }
                  else
                  { 
                    break Fail588;
                  }
                }
                if(true)
                  break Success376;
              }
              term = term121;
              IStrategoTerm term123 = term;
              Success378:
              { 
                Fail590:
                { 
                  IStrategoTerm v_453 = null;
                  IStrategoTerm w_453 = null;
                  if(term.getTermType() != IStrategoTerm.APPL || Simplify._consNeg_1 != ((IStrategoAppl)term).getConstructor())
                    break Fail590;
                  IStrategoTerm arg118 = term.getSubterm(0);
                  if(arg118.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg118).getConstructor())
                    break Fail590;
                  v_453 = arg118.getSubterm(0);
                  term = termFactory.makeTuple(Simplify.const53, v_453);
                  term = subt$S_0_0.instance.invoke(context, term);
                  if(term == null)
                    break Fail590;
                  w_453 = term;
                  term = s_480.instance.invoke(context, w_453, t_480);
                  if(term == null)
                    break Fail590;
                  term = termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{term});
                  if(true)
                    break Success378;
                }
                term = term123;
                IStrategoTerm term124 = term;
                Success379:
                { 
                  Fail591:
                  { 
                    IStrategoTerm term125 = term;
                    Success380:
                    { 
                      Fail592:
                      { 
                        IStrategoTerm a_454 = null;
                        IStrategoTerm b_454 = null;
                        IStrategoTerm c_454 = null;
                        if(term.getTermType() != IStrategoTerm.APPL || Simplify._consAdd_2 != ((IStrategoAppl)term).getConstructor())
                          break Fail592;
                        IStrategoTerm arg119 = term.getSubterm(0);
                        if(arg119.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg119).getConstructor())
                          break Fail592;
                        a_454 = arg119.getSubterm(0);
                        IStrategoTerm arg120 = term.getSubterm(1);
                        if(arg120.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg120).getConstructor())
                          break Fail592;
                        b_454 = arg120.getSubterm(0);
                        term = termFactory.makeTuple(a_454, b_454);
                        term = add$S_0_0.instance.invoke(context, term);
                        if(term == null)
                          break Fail592;
                        c_454 = term;
                        term = s_480.instance.invoke(context, c_454, t_480);
                        if(term == null)
                          break Fail592;
                        term = termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{term});
                        if(true)
                          break Success380;
                      }
                      term = term125;
                      canonical_0_0_fragment_0 canonical_0_0_fragment_00 = new canonical_0_0_fragment_0();
                      canonical_0_0_fragment_00.t_480 = t_480;
                      term = canonical_0_0_fragment_00.invoke(context, term);
                      if(term == null)
                        break Fail591;
                    }
                    if(true)
                      break Success379;
                  }
                  term = term124;
                  IStrategoTerm term165 = term;
                  Success381:
                  { 
                    Fail593:
                    { 
                      IStrategoTerm term166 = term;
                      IStrategoConstructor cons56 = term.getTermType() == IStrategoTerm.APPL ? ((IStrategoAppl)term).getConstructor() : null;
                      Success382:
                      { 
                        if(cons56 == Simplify._consAdd_2)
                        { 
                          Fail594:
                          { 
                            IStrategoTerm v_458 = null;
                            IStrategoTerm w_458 = null;
                            IStrategoTerm x_458 = null;
                            v_458 = term.getSubterm(0);
                            IStrategoTerm arg197 = term.getSubterm(1);
                            if(arg197.getTermType() != IStrategoTerm.APPL || Simplify._consAdd_2 != ((IStrategoAppl)arg197).getConstructor())
                              break Fail594;
                            w_458 = arg197.getSubterm(0);
                            x_458 = arg197.getSubterm(1);
                            term = termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{v_458, w_458});
                            term = t_480.invoke(context, term);
                            if(term == null)
                              break Fail594;
                            term = termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{term, x_458});
                            term = t_480.invoke(context, term);
                            if(term == null)
                              break Fail594;
                            if(true)
                              break Success382;
                          }
                          term = term166;
                        }
                        Success383:
                        { 
                          if(cons56 == Simplify._consMul_2)
                          { 
                            Fail595:
                            { 
                              IStrategoTerm a_459 = null;
                              IStrategoTerm b_459 = null;
                              IStrategoTerm c_459 = null;
                              a_459 = term.getSubterm(0);
                              IStrategoTerm arg198 = term.getSubterm(1);
                              if(arg198.getTermType() != IStrategoTerm.APPL || Simplify._consMul_2 != ((IStrategoAppl)arg198).getConstructor())
                                break Fail595;
                              b_459 = arg198.getSubterm(0);
                              c_459 = arg198.getSubterm(1);
                              term = termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{a_459, b_459});
                              term = t_480.invoke(context, term);
                              if(term == null)
                                break Fail595;
                              term = termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{term, c_459});
                              term = t_480.invoke(context, term);
                              if(term == null)
                                break Fail595;
                              if(true)
                                break Success383;
                            }
                            term = term166;
                          }
                          Success384:
                          { 
                            if(cons56 == Simplify._consAnd_2)
                            { 
                              Fail596:
                              { 
                                IStrategoTerm f_459 = null;
                                IStrategoTerm g_459 = null;
                                IStrategoTerm h_459 = null;
                                f_459 = term.getSubterm(0);
                                IStrategoTerm arg199 = term.getSubterm(1);
                                if(arg199.getTermType() != IStrategoTerm.APPL || Simplify._consAnd_2 != ((IStrategoAppl)arg199).getConstructor())
                                  break Fail596;
                                g_459 = arg199.getSubterm(0);
                                h_459 = arg199.getSubterm(1);
                                term = termFactory.makeAppl(Simplify._consAnd_2, new IStrategoTerm[]{f_459, g_459});
                                term = t_480.invoke(context, term);
                                if(term == null)
                                  break Fail596;
                                term = termFactory.makeAppl(Simplify._consAnd_2, new IStrategoTerm[]{term, h_459});
                                term = t_480.invoke(context, term);
                                if(term == null)
                                  break Fail596;
                                if(true)
                                  break Success384;
                              }
                              term = term166;
                            }
                            if(cons56 == Simplify._consOr_2)
                            { 
                              IStrategoTerm k_459 = null;
                              IStrategoTerm l_459 = null;
                              IStrategoTerm m_459 = null;
                              k_459 = term.getSubterm(0);
                              IStrategoTerm arg200 = term.getSubterm(1);
                              if(arg200.getTermType() != IStrategoTerm.APPL || Simplify._consOr_2 != ((IStrategoAppl)arg200).getConstructor())
                                break Fail593;
                              l_459 = arg200.getSubterm(0);
                              m_459 = arg200.getSubterm(1);
                              term = termFactory.makeAppl(Simplify._consOr_2, new IStrategoTerm[]{k_459, l_459});
                              term = t_480.invoke(context, term);
                              if(term == null)
                                break Fail593;
                              term = termFactory.makeAppl(Simplify._consOr_2, new IStrategoTerm[]{term, m_459});
                              term = t_480.invoke(context, term);
                              if(term == null)
                                break Fail593;
                            }
                            else
                            { 
                              break Fail593;
                            }
                          }
                        }
                      }
                      if(true)
                        break Success381;
                    }
                    term = term165;
                    IStrategoTerm term169 = term;
                    Success385:
                    { 
                      Fail597:
                      { 
                        IStrategoTerm term170 = term;
                        IStrategoConstructor cons57 = term.getTermType() == IStrategoTerm.APPL ? ((IStrategoAppl)term).getConstructor() : null;
                        Success386:
                        { 
                          if(cons57 == Simplify._consAdd_2)
                          { 
                            Fail598:
                            { 
                              IStrategoTerm p_459 = null;
                              IStrategoTerm q_459 = null;
                              IStrategoTerm arg201 = term.getSubterm(0);
                              if(arg201.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg201).getConstructor())
                                break Fail598;
                              q_459 = arg201.getSubterm(0);
                              p_459 = term.getSubterm(1);
                              term = termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{p_459, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{q_459})});
                              term = t_480.invoke(context, term);
                              if(term == null)
                                break Fail598;
                              if(true)
                                break Success386;
                            }
                            term = term170;
                          }
                          Success387:
                          { 
                            if(cons57 == Simplify._consAdd_2)
                            { 
                              Fail599:
                              { 
                                IStrategoTerm r_459 = null;
                                IStrategoTerm s_459 = null;
                                IStrategoTerm t_459 = null;
                                IStrategoTerm arg202 = term.getSubterm(0);
                                if(arg202.getTermType() != IStrategoTerm.APPL || Simplify._consAdd_2 != ((IStrategoAppl)arg202).getConstructor())
                                  break Fail599;
                                r_459 = arg202.getSubterm(0);
                                IStrategoTerm arg203 = arg202.getSubterm(1);
                                if(arg203.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg203).getConstructor())
                                  break Fail599;
                                t_459 = arg203.getSubterm(0);
                                s_459 = term.getSubterm(1);
                                term = termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{r_459, s_459});
                                term = t_480.invoke(context, term);
                                if(term == null)
                                  break Fail599;
                                term = termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{term, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{t_459})});
                                term = t_480.invoke(context, term);
                                if(term == null)
                                  break Fail599;
                                if(true)
                                  break Success387;
                              }
                              term = term170;
                            }
                            Success388:
                            { 
                              if(cons57 == Simplify._consMul_2)
                              { 
                                Fail600:
                                { 
                                  IStrategoTerm w_459 = null;
                                  IStrategoTerm x_459 = null;
                                  IStrategoTerm arg204 = term.getSubterm(0);
                                  if(arg204.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg204).getConstructor())
                                    break Fail600;
                                  x_459 = arg204.getSubterm(0);
                                  w_459 = term.getSubterm(1);
                                  term = termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{w_459, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{x_459})});
                                  term = t_480.invoke(context, term);
                                  if(term == null)
                                    break Fail600;
                                  if(true)
                                    break Success388;
                                }
                                term = term170;
                              }
                              Success389:
                              { 
                                if(cons57 == Simplify._consMul_2)
                                { 
                                  Fail601:
                                  { 
                                    IStrategoTerm y_459 = null;
                                    IStrategoTerm z_459 = null;
                                    IStrategoTerm a_460 = null;
                                    IStrategoTerm arg205 = term.getSubterm(0);
                                    if(arg205.getTermType() != IStrategoTerm.APPL || Simplify._consMul_2 != ((IStrategoAppl)arg205).getConstructor())
                                      break Fail601;
                                    y_459 = arg205.getSubterm(0);
                                    IStrategoTerm arg206 = arg205.getSubterm(1);
                                    if(arg206.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg206).getConstructor())
                                      break Fail601;
                                    a_460 = arg206.getSubterm(0);
                                    z_459 = term.getSubterm(1);
                                    term = termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{y_459, z_459});
                                    term = t_480.invoke(context, term);
                                    if(term == null)
                                      break Fail601;
                                    term = termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{term, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{a_460})});
                                    term = t_480.invoke(context, term);
                                    if(term == null)
                                      break Fail601;
                                    if(true)
                                      break Success389;
                                  }
                                  term = term170;
                                }
                                Success390:
                                { 
                                  if(cons57 == Simplify._consDiv_2)
                                  { 
                                    Fail602:
                                    { 
                                      IStrategoTerm d_460 = null;
                                      IStrategoTerm e_460 = null;
                                      IStrategoTerm f_460 = null;
                                      IStrategoTerm arg207 = term.getSubterm(0);
                                      if(arg207.getTermType() != IStrategoTerm.APPL || Simplify._consDiv_2 != ((IStrategoAppl)arg207).getConstructor())
                                        break Fail602;
                                      d_460 = arg207.getSubterm(0);
                                      IStrategoTerm arg208 = arg207.getSubterm(1);
                                      if(arg208.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg208).getConstructor())
                                        break Fail602;
                                      f_460 = arg208.getSubterm(0);
                                      e_460 = term.getSubterm(1);
                                      term = termFactory.makeAppl(Simplify._consDiv_2, new IStrategoTerm[]{d_460, e_460});
                                      term = t_480.invoke(context, term);
                                      if(term == null)
                                        break Fail602;
                                      term = termFactory.makeAppl(Simplify._consDiv_2, new IStrategoTerm[]{term, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{f_460})});
                                      term = t_480.invoke(context, term);
                                      if(term == null)
                                        break Fail602;
                                      if(true)
                                        break Success390;
                                    }
                                    term = term170;
                                  }
                                  Success391:
                                  { 
                                    if(cons57 == Simplify._consMul_2)
                                    { 
                                      Fail603:
                                      { 
                                        IStrategoTerm i_460 = null;
                                        IStrategoTerm j_460 = null;
                                        IStrategoTerm k_460 = null;
                                        IStrategoTerm l_460 = null;
                                        IStrategoTerm arg209 = term.getSubterm(0);
                                        if(arg209.getTermType() != IStrategoTerm.APPL || Simplify._consAdd_2 != ((IStrategoAppl)arg209).getConstructor())
                                          break Fail603;
                                        i_460 = arg209.getSubterm(0);
                                        j_460 = arg209.getSubterm(1);
                                        IStrategoTerm arg210 = term.getSubterm(1);
                                        if(arg210.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg210).getConstructor())
                                          break Fail603;
                                        k_460 = arg210.getSubterm(0);
                                        term = termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{i_460, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{k_460})});
                                        term = t_480.invoke(context, term);
                                        if(term == null)
                                          break Fail603;
                                        l_460 = term;
                                        term = termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{j_460, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{k_460})});
                                        term = t_480.invoke(context, term);
                                        if(term == null)
                                          break Fail603;
                                        term = termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{l_460, term});
                                        term = t_480.invoke(context, term);
                                        if(term == null)
                                          break Fail603;
                                        if(true)
                                          break Success391;
                                      }
                                      term = term170;
                                    }
                                    Success392:
                                    { 
                                      if(cons57 == Simplify._consAdd_2)
                                      { 
                                        Fail604:
                                        { 
                                          IStrategoTerm p_460 = null;
                                          IStrategoTerm q_460 = null;
                                          IStrategoTerm r_460 = null;
                                          IStrategoTerm arg211 = term.getSubterm(0);
                                          if(arg211.getTermType() != IStrategoTerm.APPL || Simplify._consAdd_2 != ((IStrategoAppl)arg211).getConstructor())
                                            break Fail604;
                                          p_460 = arg211.getSubterm(0);
                                          IStrategoTerm arg212 = arg211.getSubterm(1);
                                          if(arg212.getTermType() != IStrategoTerm.APPL || Simplify._consVar_1 != ((IStrategoAppl)arg212).getConstructor())
                                            break Fail604;
                                          q_460 = arg212.getSubterm(0);
                                          r_460 = term.getSubterm(1);
                                          term = termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consVar_1, new IStrategoTerm[]{q_460}), Simplify.constInt0});
                                          term = t_480.invoke(context, term);
                                          if(term == null)
                                            break Fail604;
                                          term = termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{p_460, term});
                                          term = t_480.invoke(context, term);
                                          if(term == null)
                                            break Fail604;
                                          term = termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{term, r_460});
                                          term = t_480.invoke(context, term);
                                          if(term == null)
                                            break Fail604;
                                          if(true)
                                            break Success392;
                                        }
                                        term = term170;
                                      }
                                      Success393:
                                      { 
                                        if(cons57 == Simplify._consAdd_2)
                                        { 
                                          Fail605:
                                          { 
                                            IStrategoTerm w_460 = null;
                                            IStrategoTerm x_460 = null;
                                            w_460 = term.getSubterm(0);
                                            IStrategoTerm arg213 = term.getSubterm(1);
                                            if(arg213.getTermType() != IStrategoTerm.APPL || Simplify._consVar_1 != ((IStrategoAppl)arg213).getConstructor())
                                              break Fail605;
                                            x_460 = arg213.getSubterm(0);
                                            term = termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consVar_1, new IStrategoTerm[]{x_460}), Simplify.constInt0});
                                            term = t_480.invoke(context, term);
                                            if(term == null)
                                              break Fail605;
                                            term = termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{w_460, term});
                                            term = t_480.invoke(context, term);
                                            if(term == null)
                                              break Fail605;
                                            if(true)
                                              break Success393;
                                          }
                                          term = term170;
                                        }
                                        Success394:
                                        { 
                                          if(cons57 == Simplify._consAdd_2)
                                          { 
                                            Fail606:
                                            { 
                                              IStrategoTerm a_461 = null;
                                              IStrategoTerm e_461 = null;
                                              IStrategoTerm j_461 = null;
                                              e_461 = term.getSubterm(0);
                                              a_461 = term.getSubterm(1);
                                              term = e_461;
                                              IStrategoTerm term179 = term;
                                              Success395:
                                              { 
                                                Fail607:
                                                { 
                                                  if(term.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)term).getConstructor())
                                                    break Fail607;
                                                  { 
                                                    if(true)
                                                      break Fail606;
                                                    if(true)
                                                      break Success395;
                                                  }
                                                }
                                                term = term179;
                                              }
                                              term = e_461;
                                              IStrategoTerm term180 = term;
                                              Success396:
                                              { 
                                                Fail608:
                                                { 
                                                  if(term.getTermType() != IStrategoTerm.APPL || Simplify._consMul_2 != ((IStrategoAppl)term).getConstructor())
                                                    break Fail608;
                                                  IStrategoTerm arg214 = term.getSubterm(1);
                                                  if(arg214.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg214).getConstructor())
                                                    break Fail608;
                                                  { 
                                                    if(true)
                                                      break Fail606;
                                                    if(true)
                                                      break Success396;
                                                  }
                                                }
                                                term = term180;
                                              }
                                              term = e_461;
                                              IStrategoTerm term181 = term;
                                              Success397:
                                              { 
                                                Fail609:
                                                { 
                                                  if(term.getTermType() != IStrategoTerm.APPL || Simplify._consAdd_2 != ((IStrategoAppl)term).getConstructor())
                                                    break Fail609;
                                                  { 
                                                    if(true)
                                                      break Fail606;
                                                    if(true)
                                                      break Success397;
                                                  }
                                                }
                                                term = term181;
                                              }
                                              j_461 = term;
                                              term = get_option_0_1.instance.invoke(context, j_461, Simplify.constMerge_complex_multiply0);
                                              if(term == null)
                                                break Fail606;
                                              term = termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{e_461, Simplify.constInt0});
                                              term = t_480.invoke(context, term);
                                              if(term == null)
                                                break Fail606;
                                              term = termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{term, a_461});
                                              term = t_480.invoke(context, term);
                                              if(term == null)
                                                break Fail606;
                                              if(true)
                                                break Success394;
                                            }
                                            term = term170;
                                          }
                                          canonical_0_0_fragment_1 canonical_0_0_fragment_10 = new canonical_0_0_fragment_1();
                                          canonical_0_0_fragment_10.t_480 = t_480;
                                          term = canonical_0_0_fragment_10.invoke(context, term);
                                          if(term == null)
                                            break Fail597;
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                        if(true)
                          break Success385;
                      }
                      term = term169;
                      IStrategoTerm term215 = term;
                      Success398:
                      { 
                        Fail610:
                        { 
                          IStrategoTerm term216 = term;
                          IStrategoConstructor cons61 = term.getTermType() == IStrategoTerm.APPL ? ((IStrategoAppl)term).getConstructor() : null;
                          Success399:
                          { 
                            if(cons61 == Simplify._consAdd_2)
                            { 
                              Fail611:
                              { 
                                IStrategoTerm m_467 = null;
                                IStrategoTerm n_467 = null;
                                IStrategoTerm o_467 = null;
                                IStrategoTerm p_467 = null;
                                IStrategoTerm r_467 = null;
                                IStrategoTerm arg240 = term.getSubterm(0);
                                if(arg240.getTermType() != IStrategoTerm.APPL || Simplify._consMul_2 != ((IStrategoAppl)arg240).getConstructor())
                                  break Fail611;
                                IStrategoTerm arg241 = arg240.getSubterm(0);
                                if(arg241.getTermType() != IStrategoTerm.APPL || Simplify._consVar_1 != ((IStrategoAppl)arg241).getConstructor())
                                  break Fail611;
                                o_467 = arg241.getSubterm(0);
                                IStrategoTerm arg242 = arg240.getSubterm(1);
                                if(arg242.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg242).getConstructor())
                                  break Fail611;
                                n_467 = arg242.getSubterm(0);
                                IStrategoTerm arg243 = term.getSubterm(1);
                                if(arg243.getTermType() != IStrategoTerm.APPL || Simplify._consMul_2 != ((IStrategoAppl)arg243).getConstructor())
                                  break Fail611;
                                IStrategoTerm arg244 = arg243.getSubterm(0);
                                if(arg244.getTermType() != IStrategoTerm.APPL || Simplify._consVar_1 != ((IStrategoAppl)arg244).getConstructor())
                                  break Fail611;
                                p_467 = arg244.getSubterm(0);
                                IStrategoTerm arg245 = arg243.getSubterm(1);
                                if(arg245.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg245).getConstructor())
                                  break Fail611;
                                m_467 = arg245.getSubterm(0);
                                term = termFactory.makeTuple(o_467, p_467);
                                term = variable_name_reorder_0_0.instance.invoke(context, term);
                                if(term == null)
                                  break Fail611;
                                term = termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consVar_1, new IStrategoTerm[]{p_467}), termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{m_467})});
                                term = t_480.invoke(context, term);
                                if(term == null)
                                  break Fail611;
                                r_467 = term;
                                term = termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consVar_1, new IStrategoTerm[]{o_467}), termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{n_467})});
                                term = t_480.invoke(context, term);
                                if(term == null)
                                  break Fail611;
                                term = termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{r_467, term});
                                term = t_480.invoke(context, term);
                                if(term == null)
                                  break Fail611;
                                if(true)
                                  break Success399;
                              }
                              term = term216;
                            }
                            Success400:
                            { 
                              if(cons61 == Simplify._consAdd_2)
                              { 
                                Fail612:
                                { 
                                  IStrategoTerm v_467 = null;
                                  IStrategoTerm w_467 = null;
                                  IStrategoTerm x_467 = null;
                                  IStrategoTerm y_467 = null;
                                  IStrategoTerm z_467 = null;
                                  IStrategoTerm b_468 = null;
                                  IStrategoTerm arg246 = term.getSubterm(0);
                                  if(arg246.getTermType() != IStrategoTerm.APPL || Simplify._consAdd_2 != ((IStrategoAppl)arg246).getConstructor())
                                    break Fail612;
                                  v_467 = arg246.getSubterm(0);
                                  IStrategoTerm arg247 = arg246.getSubterm(1);
                                  if(arg247.getTermType() != IStrategoTerm.APPL || Simplify._consMul_2 != ((IStrategoAppl)arg247).getConstructor())
                                    break Fail612;
                                  IStrategoTerm arg248 = arg247.getSubterm(0);
                                  if(arg248.getTermType() != IStrategoTerm.APPL || Simplify._consVar_1 != ((IStrategoAppl)arg248).getConstructor())
                                    break Fail612;
                                  y_467 = arg248.getSubterm(0);
                                  IStrategoTerm arg249 = arg247.getSubterm(1);
                                  if(arg249.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg249).getConstructor())
                                    break Fail612;
                                  x_467 = arg249.getSubterm(0);
                                  IStrategoTerm arg250 = term.getSubterm(1);
                                  if(arg250.getTermType() != IStrategoTerm.APPL || Simplify._consMul_2 != ((IStrategoAppl)arg250).getConstructor())
                                    break Fail612;
                                  IStrategoTerm arg251 = arg250.getSubterm(0);
                                  if(arg251.getTermType() != IStrategoTerm.APPL || Simplify._consVar_1 != ((IStrategoAppl)arg251).getConstructor())
                                    break Fail612;
                                  z_467 = arg251.getSubterm(0);
                                  IStrategoTerm arg252 = arg250.getSubterm(1);
                                  if(arg252.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg252).getConstructor())
                                    break Fail612;
                                  w_467 = arg252.getSubterm(0);
                                  term = termFactory.makeTuple(y_467, z_467);
                                  term = variable_name_reorder_0_0.instance.invoke(context, term);
                                  if(term == null)
                                    break Fail612;
                                  term = termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consVar_1, new IStrategoTerm[]{z_467}), termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{w_467})});
                                  term = t_480.invoke(context, term);
                                  if(term == null)
                                    break Fail612;
                                  term = termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{v_467, term});
                                  term = t_480.invoke(context, term);
                                  if(term == null)
                                    break Fail612;
                                  b_468 = term;
                                  term = termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consVar_1, new IStrategoTerm[]{y_467}), termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{x_467})});
                                  term = t_480.invoke(context, term);
                                  if(term == null)
                                    break Fail612;
                                  term = termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{b_468, term});
                                  term = t_480.invoke(context, term);
                                  if(term == null)
                                    break Fail612;
                                  if(true)
                                    break Success400;
                                }
                                term = term216;
                              }
                              Success401:
                              { 
                                if(cons61 == Simplify._consAdd_2)
                                { 
                                  Fail613:
                                  { 
                                    IStrategoTerm h_468 = null;
                                    IStrategoTerm i_468 = null;
                                    h_468 = term.getSubterm(0);
                                    i_468 = term.getSubterm(1);
                                    term = h_468;
                                    IStrategoTerm term219 = term;
                                    Success402:
                                    { 
                                      Fail614:
                                      { 
                                        if(term.getTermType() != IStrategoTerm.APPL || Simplify._consAdd_2 != ((IStrategoAppl)term).getConstructor())
                                          break Fail614;
                                        { 
                                          if(true)
                                            break Fail613;
                                          if(true)
                                            break Success402;
                                        }
                                      }
                                      term = term219;
                                    }
                                    term = h_468;
                                    IStrategoTerm term220 = term;
                                    Success403:
                                    { 
                                      Fail615:
                                      { 
                                        if(term.getTermType() != IStrategoTerm.APPL || Simplify._consMul_2 != ((IStrategoAppl)term).getConstructor())
                                          break Fail615;
                                        IStrategoTerm arg255 = term.getSubterm(0);
                                        if(arg255.getTermType() != IStrategoTerm.APPL || Simplify._consVar_1 != ((IStrategoAppl)arg255).getConstructor())
                                          break Fail615;
                                        IStrategoTerm arg257 = term.getSubterm(1);
                                        if(arg257.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg257).getConstructor())
                                          break Fail615;
                                        { 
                                          if(true)
                                            break Fail613;
                                          if(true)
                                            break Success403;
                                        }
                                      }
                                      term = term220;
                                    }
                                    term = i_468;
                                    if(term.getTermType() != IStrategoTerm.APPL || Simplify._consMul_2 != ((IStrategoAppl)term).getConstructor())
                                      break Fail613;
                                    IStrategoTerm arg259 = term.getSubterm(0);
                                    if(arg259.getTermType() != IStrategoTerm.APPL || Simplify._consVar_1 != ((IStrategoAppl)arg259).getConstructor())
                                      break Fail613;
                                    IStrategoTerm arg261 = term.getSubterm(1);
                                    if(arg261.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg261).getConstructor())
                                      break Fail613;
                                    term = termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{i_468, h_468});
                                    term = t_480.invoke(context, term);
                                    if(term == null)
                                      break Fail613;
                                    if(true)
                                      break Success401;
                                  }
                                  term = term216;
                                }
                                if(cons61 == Simplify._consAdd_2)
                                { 
                                  IStrategoTerm k_468 = null;
                                  IStrategoTerm l_468 = null;
                                  IStrategoTerm m_468 = null;
                                  IStrategoTerm arg263 = term.getSubterm(0);
                                  if(arg263.getTermType() != IStrategoTerm.APPL || Simplify._consAdd_2 != ((IStrategoAppl)arg263).getConstructor())
                                    break Fail610;
                                  k_468 = arg263.getSubterm(0);
                                  l_468 = arg263.getSubterm(1);
                                  m_468 = term.getSubterm(1);
                                  term = l_468;
                                  IStrategoTerm term221 = term;
                                  Success404:
                                  { 
                                    Fail616:
                                    { 
                                      if(term.getTermType() != IStrategoTerm.APPL || Simplify._consMul_2 != ((IStrategoAppl)term).getConstructor())
                                        break Fail616;
                                      IStrategoTerm arg264 = term.getSubterm(0);
                                      if(arg264.getTermType() != IStrategoTerm.APPL || Simplify._consVar_1 != ((IStrategoAppl)arg264).getConstructor())
                                        break Fail616;
                                      IStrategoTerm arg266 = term.getSubterm(1);
                                      if(arg266.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg266).getConstructor())
                                        break Fail616;
                                      { 
                                        if(true)
                                          break Fail610;
                                        if(true)
                                          break Success404;
                                      }
                                    }
                                    term = term221;
                                  }
                                  term = m_468;
                                  if(term.getTermType() != IStrategoTerm.APPL || Simplify._consMul_2 != ((IStrategoAppl)term).getConstructor())
                                    break Fail610;
                                  IStrategoTerm arg268 = term.getSubterm(0);
                                  if(arg268.getTermType() != IStrategoTerm.APPL || Simplify._consVar_1 != ((IStrategoAppl)arg268).getConstructor())
                                    break Fail610;
                                  IStrategoTerm arg270 = term.getSubterm(1);
                                  if(arg270.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg270).getConstructor())
                                    break Fail610;
                                  term = termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{k_468, m_468});
                                  term = t_480.invoke(context, term);
                                  if(term == null)
                                    break Fail610;
                                  term = termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{term, l_468});
                                  term = t_480.invoke(context, term);
                                  if(term == null)
                                    break Fail610;
                                }
                                else
                                { 
                                  break Fail610;
                                }
                              }
                            }
                          }
                          if(true)
                            break Success398;
                        }
                        term = term215;
                        IStrategoTerm term222 = term;
                        IStrategoConstructor cons65 = term.getTermType() == IStrategoTerm.APPL ? ((IStrategoAppl)term).getConstructor() : null;
                        Success405:
                        { 
                          if(cons65 == Simplify._consKnown_1)
                          { 
                            Fail617:
                            { 
                              IStrategoTerm arg272 = term.getSubterm(0);
                              if(arg272.getTermType() != IStrategoTerm.APPL || Simplify._consTrue_0 != ((IStrategoAppl)arg272).getConstructor())
                                break Fail617;
                              term = Simplify.constTrue0;
                              if(true)
                                break Success405;
                            }
                            term = term222;
                          }
                          Success406:
                          { 
                            if(cons65 == Simplify._consKnown_1)
                            { 
                              Fail618:
                              { 
                                term = Simplify.constFalse0;
                                if(true)
                                  break Success406;
                              }
                              term = term222;
                            }
                            canonical_0_0_fragment_3 canonical_0_0_fragment_30 = new canonical_0_0_fragment_3();
                            canonical_0_0_fragment_30.t_480 = t_480;
                            term = canonical_0_0_fragment_30.invoke(context, term);
                            if(term == null)
                              break Fail577;
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class canonical_0_0_fragment_3 extends Strategy 
  { 
    Strategy t_480;

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      ITermFactory termFactory = context.getFactory();
      Fail619:
      { 
        IStrategoTerm term224 = term;
        Success407:
        { 
          Fail620:
          { 
            IStrategoTerm term225 = term;
            IStrategoConstructor cons66 = term.getTermType() == IStrategoTerm.APPL ? ((IStrategoAppl)term).getConstructor() : null;
            Success408:
            { 
              if(cons66 == Simplify._consNeq_2)
              { 
                Fail621:
                { 
                  IStrategoTerm r_468 = null;
                  IStrategoTerm s_468 = null;
                  IStrategoTerm v_468 = null;
                  s_468 = term.getSubterm(0);
                  IStrategoTerm arg273 = term.getSubterm(1);
                  if(arg273.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg273).getConstructor())
                    break Fail621;
                  r_468 = arg273.getSubterm(0);
                  term = first_mul_0_0.instance.invoke(context, s_468);
                  if(term == null)
                    break Fail621;
                  term = termFactory.makeTuple(term, Simplify.const53);
                  term = lt$S_0_0.instance.invoke(context, term);
                  if(term == null)
                    break Fail621;
                  term = termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{s_468, Simplify.constInt2});
                  term = t_480.invoke(context, term);
                  if(term == null)
                    break Fail621;
                  v_468 = term;
                  term = termFactory.makeAppl(Simplify._consNeg_1, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{r_468})});
                  term = t_480.invoke(context, term);
                  if(term == null)
                    break Fail621;
                  term = termFactory.makeAppl(Simplify._consNeq_2, new IStrategoTerm[]{v_468, term});
                  term = t_480.invoke(context, term);
                  if(term == null)
                    break Fail621;
                  if(true)
                    break Success408;
                }
                term = term225;
              }
              Success409:
              { 
                if(cons66 == Simplify._consEqu_2)
                { 
                  Fail622:
                  { 
                    IStrategoTerm z_468 = null;
                    IStrategoTerm a_469 = null;
                    IStrategoTerm d_469 = null;
                    a_469 = term.getSubterm(0);
                    IStrategoTerm arg274 = term.getSubterm(1);
                    if(arg274.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg274).getConstructor())
                      break Fail622;
                    z_468 = arg274.getSubterm(0);
                    term = first_mul_0_0.instance.invoke(context, a_469);
                    if(term == null)
                      break Fail622;
                    term = termFactory.makeTuple(term, Simplify.const53);
                    term = lt$S_0_0.instance.invoke(context, term);
                    if(term == null)
                      break Fail622;
                    term = termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{a_469, Simplify.constInt2});
                    term = t_480.invoke(context, term);
                    if(term == null)
                      break Fail622;
                    d_469 = term;
                    term = termFactory.makeAppl(Simplify._consNeg_1, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{z_468})});
                    term = t_480.invoke(context, term);
                    if(term == null)
                      break Fail622;
                    term = termFactory.makeAppl(Simplify._consEqu_2, new IStrategoTerm[]{d_469, term});
                    term = t_480.invoke(context, term);
                    if(term == null)
                      break Fail622;
                    if(true)
                      break Success409;
                  }
                  term = term225;
                }
                Success410:
                { 
                  if(cons66 == Simplify._consLt_2)
                  { 
                    Fail623:
                    { 
                      IStrategoTerm h_469 = null;
                      IStrategoTerm i_469 = null;
                      IStrategoTerm l_469 = null;
                      i_469 = term.getSubterm(0);
                      IStrategoTerm arg275 = term.getSubterm(1);
                      if(arg275.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg275).getConstructor())
                        break Fail623;
                      h_469 = arg275.getSubterm(0);
                      term = first_mul_0_0.instance.invoke(context, i_469);
                      if(term == null)
                        break Fail623;
                      term = termFactory.makeTuple(term, Simplify.const53);
                      term = lt$S_0_0.instance.invoke(context, term);
                      if(term == null)
                        break Fail623;
                      term = termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{i_469, Simplify.constInt2});
                      term = t_480.invoke(context, term);
                      if(term == null)
                        break Fail623;
                      l_469 = term;
                      term = termFactory.makeAppl(Simplify._consNeg_1, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{h_469})});
                      term = t_480.invoke(context, term);
                      if(term == null)
                        break Fail623;
                      term = termFactory.makeAppl(Simplify._consGt_2, new IStrategoTerm[]{l_469, term});
                      term = t_480.invoke(context, term);
                      if(term == null)
                        break Fail623;
                      if(true)
                        break Success410;
                    }
                    term = term225;
                  }
                  Success411:
                  { 
                    if(cons66 == Simplify._consLeq_2)
                    { 
                      Fail624:
                      { 
                        IStrategoTerm p_469 = null;
                        IStrategoTerm q_469 = null;
                        IStrategoTerm t_469 = null;
                        q_469 = term.getSubterm(0);
                        IStrategoTerm arg276 = term.getSubterm(1);
                        if(arg276.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg276).getConstructor())
                          break Fail624;
                        p_469 = arg276.getSubterm(0);
                        term = first_mul_0_0.instance.invoke(context, q_469);
                        if(term == null)
                          break Fail624;
                        term = termFactory.makeTuple(term, Simplify.const53);
                        term = lt$S_0_0.instance.invoke(context, term);
                        if(term == null)
                          break Fail624;
                        term = termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{q_469, Simplify.constInt2});
                        term = t_480.invoke(context, term);
                        if(term == null)
                          break Fail624;
                        t_469 = term;
                        term = termFactory.makeAppl(Simplify._consNeg_1, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{p_469})});
                        term = t_480.invoke(context, term);
                        if(term == null)
                          break Fail624;
                        term = termFactory.makeAppl(Simplify._consGeq_2, new IStrategoTerm[]{t_469, term});
                        term = t_480.invoke(context, term);
                        if(term == null)
                          break Fail624;
                        if(true)
                          break Success411;
                      }
                      term = term225;
                    }
                    Success412:
                    { 
                      if(cons66 == Simplify._consGt_2)
                      { 
                        Fail625:
                        { 
                          IStrategoTerm x_469 = null;
                          IStrategoTerm y_469 = null;
                          IStrategoTerm b_470 = null;
                          y_469 = term.getSubterm(0);
                          IStrategoTerm arg277 = term.getSubterm(1);
                          if(arg277.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg277).getConstructor())
                            break Fail625;
                          x_469 = arg277.getSubterm(0);
                          term = first_mul_0_0.instance.invoke(context, y_469);
                          if(term == null)
                            break Fail625;
                          term = termFactory.makeTuple(term, Simplify.const53);
                          term = lt$S_0_0.instance.invoke(context, term);
                          if(term == null)
                            break Fail625;
                          term = termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{y_469, Simplify.constInt2});
                          term = t_480.invoke(context, term);
                          if(term == null)
                            break Fail625;
                          b_470 = term;
                          term = termFactory.makeAppl(Simplify._consNeg_1, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{x_469})});
                          term = t_480.invoke(context, term);
                          if(term == null)
                            break Fail625;
                          term = termFactory.makeAppl(Simplify._consLt_2, new IStrategoTerm[]{b_470, term});
                          term = t_480.invoke(context, term);
                          if(term == null)
                            break Fail625;
                          if(true)
                            break Success412;
                        }
                        term = term225;
                      }
                      if(cons66 == Simplify._consGeq_2)
                      { 
                        IStrategoTerm f_470 = null;
                        IStrategoTerm g_470 = null;
                        IStrategoTerm j_470 = null;
                        g_470 = term.getSubterm(0);
                        IStrategoTerm arg278 = term.getSubterm(1);
                        if(arg278.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg278).getConstructor())
                          break Fail620;
                        f_470 = arg278.getSubterm(0);
                        term = first_mul_0_0.instance.invoke(context, g_470);
                        if(term == null)
                          break Fail620;
                        term = termFactory.makeTuple(term, Simplify.const53);
                        term = lt$S_0_0.instance.invoke(context, term);
                        if(term == null)
                          break Fail620;
                        term = termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{g_470, Simplify.constInt2});
                        term = t_480.invoke(context, term);
                        if(term == null)
                          break Fail620;
                        j_470 = term;
                        term = termFactory.makeAppl(Simplify._consNeg_1, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{f_470})});
                        term = t_480.invoke(context, term);
                        if(term == null)
                          break Fail620;
                        term = termFactory.makeAppl(Simplify._consLeq_2, new IStrategoTerm[]{j_470, term});
                        term = t_480.invoke(context, term);
                        if(term == null)
                          break Fail620;
                      }
                      else
                      { 
                        break Fail620;
                      }
                    }
                  }
                }
              }
            }
            if(true)
              break Success407;
          }
          term = term224;
          IStrategoTerm term230 = term;
          Success413:
          { 
            Fail626:
            { 
              IStrategoTerm term231 = term;
              IStrategoConstructor cons67 = term.getTermType() == IStrategoTerm.APPL ? ((IStrategoAppl)term).getConstructor() : null;
              Success414:
              { 
                if(cons67 == Simplify._consAnd_2)
                { 
                  Fail627:
                  { 
                    IStrategoTerm n_470 = null;
                    IStrategoTerm o_470 = null;
                    n_470 = term.getSubterm(0);
                    o_470 = term.getSubterm(1);
                    term = termFactory.makeTuple(n_470, o_470);
                    term = comparison_reorder_0_0.instance.invoke(context, term);
                    if(term == null)
                      break Fail627;
                    term = termFactory.makeAppl(Simplify._consAnd_2, new IStrategoTerm[]{o_470, n_470});
                    term = t_480.invoke(context, term);
                    if(term == null)
                      break Fail627;
                    if(true)
                      break Success414;
                  }
                  term = term231;
                }
                Success415:
                { 
                  if(cons67 == Simplify._consAnd_2)
                  { 
                    Fail628:
                    { 
                      IStrategoTerm q_470 = null;
                      IStrategoTerm r_470 = null;
                      IStrategoTerm s_470 = null;
                      IStrategoTerm arg279 = term.getSubterm(0);
                      if(arg279.getTermType() != IStrategoTerm.APPL || Simplify._consAnd_2 != ((IStrategoAppl)arg279).getConstructor())
                        break Fail628;
                      q_470 = arg279.getSubterm(0);
                      r_470 = arg279.getSubterm(1);
                      s_470 = term.getSubterm(1);
                      term = termFactory.makeTuple(r_470, s_470);
                      term = comparison_reorder_0_0.instance.invoke(context, term);
                      if(term == null)
                        break Fail628;
                      term = termFactory.makeAppl(Simplify._consAnd_2, new IStrategoTerm[]{q_470, s_470});
                      term = t_480.invoke(context, term);
                      if(term == null)
                        break Fail628;
                      term = termFactory.makeAppl(Simplify._consAnd_2, new IStrategoTerm[]{term, r_470});
                      term = t_480.invoke(context, term);
                      if(term == null)
                        break Fail628;
                      if(true)
                        break Success415;
                    }
                    term = term231;
                  }
                  Success416:
                  { 
                    if(cons67 == Simplify._consOr_2)
                    { 
                      Fail629:
                      { 
                        IStrategoTerm w_470 = null;
                        IStrategoTerm x_470 = null;
                        w_470 = term.getSubterm(0);
                        x_470 = term.getSubterm(1);
                        term = termFactory.makeTuple(w_470, x_470);
                        term = comparison_reorder_0_0.instance.invoke(context, term);
                        if(term == null)
                          break Fail629;
                        term = termFactory.makeAppl(Simplify._consOr_2, new IStrategoTerm[]{x_470, w_470});
                        term = t_480.invoke(context, term);
                        if(term == null)
                          break Fail629;
                        if(true)
                          break Success416;
                      }
                      term = term231;
                    }
                    if(cons67 == Simplify._consOr_2)
                    { 
                      IStrategoTerm z_470 = null;
                      IStrategoTerm a_471 = null;
                      IStrategoTerm b_471 = null;
                      IStrategoTerm arg280 = term.getSubterm(0);
                      if(arg280.getTermType() != IStrategoTerm.APPL || Simplify._consOr_2 != ((IStrategoAppl)arg280).getConstructor())
                        break Fail626;
                      z_470 = arg280.getSubterm(0);
                      a_471 = arg280.getSubterm(1);
                      b_471 = term.getSubterm(1);
                      term = termFactory.makeTuple(a_471, b_471);
                      term = comparison_reorder_0_0.instance.invoke(context, term);
                      if(term == null)
                        break Fail626;
                      term = termFactory.makeAppl(Simplify._consOr_2, new IStrategoTerm[]{z_470, b_471});
                      term = t_480.invoke(context, term);
                      if(term == null)
                        break Fail626;
                      term = termFactory.makeAppl(Simplify._consOr_2, new IStrategoTerm[]{term, a_471});
                      term = t_480.invoke(context, term);
                      if(term == null)
                        break Fail626;
                    }
                    else
                    { 
                      break Fail626;
                    }
                  }
                }
              }
              if(true)
                break Success413;
            }
            term = term230;
            IStrategoTerm term234 = term;
            IStrategoConstructor cons68 = term.getTermType() == IStrategoTerm.APPL ? ((IStrategoAppl)term).getConstructor() : null;
            Success417:
            { 
              if(cons68 == Simplify._consAnd_2)
              { 
                Fail630:
                { 
                  IStrategoTerm f_471 = null;
                  IStrategoTerm g_471 = null;
                  IStrategoTerm h_471 = null;
                  IStrategoTerm i_471 = null;
                  IStrategoTerm arg281 = term.getSubterm(0);
                  if(arg281.getTermType() != IStrategoTerm.APPL || Simplify._consLt_2 != ((IStrategoAppl)arg281).getConstructor())
                    break Fail630;
                  f_471 = arg281.getSubterm(0);
                  IStrategoTerm arg282 = arg281.getSubterm(1);
                  if(arg282.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg282).getConstructor())
                    break Fail630;
                  g_471 = arg282.getSubterm(0);
                  IStrategoTerm arg283 = term.getSubterm(1);
                  if(arg283.getTermType() != IStrategoTerm.APPL || Simplify._consLt_2 != ((IStrategoAppl)arg283).getConstructor())
                    break Fail630;
                  if(arg283.getSubterm(0) != f_471 && !f_471.match(arg283.getSubterm(0)))
                    break Fail630;
                  IStrategoTerm arg284 = arg283.getSubterm(1);
                  if(arg284.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg284).getConstructor())
                    break Fail630;
                  h_471 = arg284.getSubterm(0);
                  term = termFactory.makeTuple(g_471, h_471);
                  term = minstring_0_0.instance.invoke(context, term);
                  if(term == null)
                    break Fail630;
                  i_471 = term;
                  term = s_480.instance.invoke(context, i_471, t_480);
                  if(term == null)
                    break Fail630;
                  term = termFactory.makeAppl(Simplify._consLt_2, new IStrategoTerm[]{f_471, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{term})});
                  term = t_480.invoke(context, term);
                  if(term == null)
                    break Fail630;
                  if(true)
                    break Success417;
                }
                term = term234;
              }
              Success418:
              { 
                if(cons68 == Simplify._consAnd_2)
                { 
                  Fail631:
                  { 
                    IStrategoTerm m_471 = null;
                    IStrategoTerm n_471 = null;
                    IStrategoTerm o_471 = null;
                    IStrategoTerm arg285 = term.getSubterm(0);
                    if(arg285.getTermType() != IStrategoTerm.APPL || Simplify._consLt_2 != ((IStrategoAppl)arg285).getConstructor())
                      break Fail631;
                    m_471 = arg285.getSubterm(0);
                    IStrategoTerm arg286 = arg285.getSubterm(1);
                    if(arg286.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg286).getConstructor())
                      break Fail631;
                    n_471 = arg286.getSubterm(0);
                    IStrategoTerm arg287 = term.getSubterm(1);
                    if(arg287.getTermType() != IStrategoTerm.APPL || Simplify._consLeq_2 != ((IStrategoAppl)arg287).getConstructor())
                      break Fail631;
                    if(arg287.getSubterm(0) != m_471 && !m_471.match(arg287.getSubterm(0)))
                      break Fail631;
                    IStrategoTerm arg288 = arg287.getSubterm(1);
                    if(arg288.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg288).getConstructor())
                      break Fail631;
                    o_471 = arg288.getSubterm(0);
                    term = termFactory.makeTuple(n_471, o_471);
                    term = gt$S_0_0.instance.invoke(context, term);
                    if(term == null)
                      break Fail631;
                    term = termFactory.makeAppl(Simplify._consLeq_2, new IStrategoTerm[]{m_471, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{o_471})});
                    term = t_480.invoke(context, term);
                    if(term == null)
                      break Fail631;
                    if(true)
                      break Success418;
                  }
                  term = term234;
                }
                Success419:
                { 
                  if(cons68 == Simplify._consAnd_2)
                  { 
                    Fail632:
                    { 
                      IStrategoTerm q_471 = null;
                      IStrategoTerm r_471 = null;
                      IStrategoTerm s_471 = null;
                      IStrategoTerm arg289 = term.getSubterm(0);
                      if(arg289.getTermType() != IStrategoTerm.APPL || Simplify._consLt_2 != ((IStrategoAppl)arg289).getConstructor())
                        break Fail632;
                      q_471 = arg289.getSubterm(0);
                      IStrategoTerm arg290 = arg289.getSubterm(1);
                      if(arg290.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg290).getConstructor())
                        break Fail632;
                      r_471 = arg290.getSubterm(0);
                      IStrategoTerm arg291 = term.getSubterm(1);
                      if(arg291.getTermType() != IStrategoTerm.APPL || Simplify._consLeq_2 != ((IStrategoAppl)arg291).getConstructor())
                        break Fail632;
                      if(arg291.getSubterm(0) != q_471 && !q_471.match(arg291.getSubterm(0)))
                        break Fail632;
                      IStrategoTerm arg292 = arg291.getSubterm(1);
                      if(arg292.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg292).getConstructor())
                        break Fail632;
                      s_471 = arg292.getSubterm(0);
                      term = termFactory.makeTuple(r_471, s_471);
                      term = leq$S_0_0.instance.invoke(context, term);
                      if(term == null)
                        break Fail632;
                      term = termFactory.makeAppl(Simplify._consLt_2, new IStrategoTerm[]{q_471, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{r_471})});
                      term = t_480.invoke(context, term);
                      if(term == null)
                        break Fail632;
                      if(true)
                        break Success419;
                    }
                    term = term234;
                  }
                  Success420:
                  { 
                    if(cons68 == Simplify._consAnd_2)
                    { 
                      Fail633:
                      { 
                        IStrategoTerm u_471 = null;
                        IStrategoTerm v_471 = null;
                        IStrategoTerm w_471 = null;
                        IStrategoTerm x_471 = null;
                        IStrategoTerm arg293 = term.getSubterm(0);
                        if(arg293.getTermType() != IStrategoTerm.APPL || Simplify._consLeq_2 != ((IStrategoAppl)arg293).getConstructor())
                          break Fail633;
                        u_471 = arg293.getSubterm(0);
                        IStrategoTerm arg294 = arg293.getSubterm(1);
                        if(arg294.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg294).getConstructor())
                          break Fail633;
                        v_471 = arg294.getSubterm(0);
                        IStrategoTerm arg295 = term.getSubterm(1);
                        if(arg295.getTermType() != IStrategoTerm.APPL || Simplify._consLeq_2 != ((IStrategoAppl)arg295).getConstructor())
                          break Fail633;
                        if(arg295.getSubterm(0) != u_471 && !u_471.match(arg295.getSubterm(0)))
                          break Fail633;
                        IStrategoTerm arg296 = arg295.getSubterm(1);
                        if(arg296.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg296).getConstructor())
                          break Fail633;
                        w_471 = arg296.getSubterm(0);
                        term = termFactory.makeTuple(v_471, w_471);
                        term = minstring_0_0.instance.invoke(context, term);
                        if(term == null)
                          break Fail633;
                        x_471 = term;
                        term = s_480.instance.invoke(context, x_471, t_480);
                        if(term == null)
                          break Fail633;
                        term = termFactory.makeAppl(Simplify._consLeq_2, new IStrategoTerm[]{u_471, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{term})});
                        term = t_480.invoke(context, term);
                        if(term == null)
                          break Fail633;
                        if(true)
                          break Success420;
                      }
                      term = term234;
                    }
                    Success421:
                    { 
                      if(cons68 == Simplify._consAnd_2)
                      { 
                        Fail634:
                        { 
                          IStrategoTerm b_472 = null;
                          IStrategoTerm c_472 = null;
                          IStrategoTerm d_472 = null;
                          IStrategoTerm arg297 = term.getSubterm(0);
                          if(arg297.getTermType() != IStrategoTerm.APPL || Simplify._consEqu_2 != ((IStrategoAppl)arg297).getConstructor())
                            break Fail634;
                          b_472 = arg297.getSubterm(0);
                          IStrategoTerm arg298 = arg297.getSubterm(1);
                          if(arg298.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg298).getConstructor())
                            break Fail634;
                          c_472 = arg298.getSubterm(0);
                          IStrategoTerm arg299 = term.getSubterm(1);
                          if(arg299.getTermType() != IStrategoTerm.APPL || Simplify._consEqu_2 != ((IStrategoAppl)arg299).getConstructor())
                            break Fail634;
                          if(arg299.getSubterm(0) != b_472 && !b_472.match(arg299.getSubterm(0)))
                            break Fail634;
                          IStrategoTerm arg300 = arg299.getSubterm(1);
                          if(arg300.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg300).getConstructor())
                            break Fail634;
                          d_472 = arg300.getSubterm(0);
                          term = termFactory.makeTuple(c_472, d_472);
                          IStrategoTerm term239 = term;
                          Success422:
                          { 
                            Fail635:
                            { 
                              term = eq_0_0.instance.invoke(context, term);
                              if(term == null)
                                break Fail635;
                              { 
                                if(true)
                                  break Fail634;
                                if(true)
                                  break Success422;
                              }
                            }
                            term = term239;
                          }
                          term = Simplify.constFalse0;
                          if(true)
                            break Success421;
                        }
                        term = term234;
                      }
                      Success423:
                      { 
                        if(cons68 == Simplify._consAnd_2)
                        { 
                          Fail636:
                          { 
                            IStrategoTerm f_472 = null;
                            IStrategoTerm g_472 = null;
                            IStrategoTerm arg301 = term.getSubterm(0);
                            if(arg301.getTermType() != IStrategoTerm.APPL || Simplify._consEqu_2 != ((IStrategoAppl)arg301).getConstructor())
                              break Fail636;
                            f_472 = arg301.getSubterm(0);
                            IStrategoTerm arg302 = arg301.getSubterm(1);
                            if(arg302.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg302).getConstructor())
                              break Fail636;
                            g_472 = arg302.getSubterm(0);
                            IStrategoTerm arg303 = term.getSubterm(1);
                            if(arg303.getTermType() != IStrategoTerm.APPL || Simplify._consEqu_2 != ((IStrategoAppl)arg303).getConstructor())
                              break Fail636;
                            if(arg303.getSubterm(0) != f_472 && !f_472.match(arg303.getSubterm(0)))
                              break Fail636;
                            IStrategoTerm arg304 = arg303.getSubterm(1);
                            if(arg304.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg304).getConstructor())
                              break Fail636;
                            if(arg304.getSubterm(0) != g_472 && !g_472.match(arg304.getSubterm(0)))
                              break Fail636;
                            term = termFactory.makeAppl(Simplify._consEqu_2, new IStrategoTerm[]{f_472, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{g_472})});
                            term = t_480.invoke(context, term);
                            if(term == null)
                              break Fail636;
                            if(true)
                              break Success423;
                          }
                          term = term234;
                        }
                        Success424:
                        { 
                          if(cons68 == Simplify._consAnd_2)
                          { 
                            Fail637:
                            { 
                              IStrategoTerm h_472 = null;
                              IStrategoTerm i_472 = null;
                              IStrategoTerm j_472 = null;
                              IStrategoTerm k_472 = null;
                              IStrategoTerm arg305 = term.getSubterm(0);
                              if(arg305.getTermType() != IStrategoTerm.APPL || Simplify._consGeq_2 != ((IStrategoAppl)arg305).getConstructor())
                                break Fail637;
                              h_472 = arg305.getSubterm(0);
                              IStrategoTerm arg306 = arg305.getSubterm(1);
                              if(arg306.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg306).getConstructor())
                                break Fail637;
                              i_472 = arg306.getSubterm(0);
                              IStrategoTerm arg307 = term.getSubterm(1);
                              if(arg307.getTermType() != IStrategoTerm.APPL || Simplify._consGeq_2 != ((IStrategoAppl)arg307).getConstructor())
                                break Fail637;
                              if(arg307.getSubterm(0) != h_472 && !h_472.match(arg307.getSubterm(0)))
                                break Fail637;
                              IStrategoTerm arg308 = arg307.getSubterm(1);
                              if(arg308.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg308).getConstructor())
                                break Fail637;
                              j_472 = arg308.getSubterm(0);
                              term = termFactory.makeTuple(i_472, j_472);
                              term = maxstring_0_0.instance.invoke(context, term);
                              if(term == null)
                                break Fail637;
                              k_472 = term;
                              term = s_480.instance.invoke(context, k_472, t_480);
                              if(term == null)
                                break Fail637;
                              term = termFactory.makeAppl(Simplify._consGeq_2, new IStrategoTerm[]{h_472, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{term})});
                              term = t_480.invoke(context, term);
                              if(term == null)
                                break Fail637;
                              if(true)
                                break Success424;
                            }
                            term = term234;
                          }
                          Success425:
                          { 
                            if(cons68 == Simplify._consAnd_2)
                            { 
                              Fail638:
                              { 
                                IStrategoTerm o_472 = null;
                                IStrategoTerm p_472 = null;
                                IStrategoTerm q_472 = null;
                                IStrategoTerm arg309 = term.getSubterm(0);
                                if(arg309.getTermType() != IStrategoTerm.APPL || Simplify._consGeq_2 != ((IStrategoAppl)arg309).getConstructor())
                                  break Fail638;
                                o_472 = arg309.getSubterm(0);
                                IStrategoTerm arg310 = arg309.getSubterm(1);
                                if(arg310.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg310).getConstructor())
                                  break Fail638;
                                p_472 = arg310.getSubterm(0);
                                IStrategoTerm arg311 = term.getSubterm(1);
                                if(arg311.getTermType() != IStrategoTerm.APPL || Simplify._consGt_2 != ((IStrategoAppl)arg311).getConstructor())
                                  break Fail638;
                                if(arg311.getSubterm(0) != o_472 && !o_472.match(arg311.getSubterm(0)))
                                  break Fail638;
                                IStrategoTerm arg312 = arg311.getSubterm(1);
                                if(arg312.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg312).getConstructor())
                                  break Fail638;
                                q_472 = arg312.getSubterm(0);
                                term = termFactory.makeTuple(p_472, q_472);
                                term = gt$S_0_0.instance.invoke(context, term);
                                if(term == null)
                                  break Fail638;
                                term = termFactory.makeAppl(Simplify._consGeq_2, new IStrategoTerm[]{o_472, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{p_472})});
                                term = t_480.invoke(context, term);
                                if(term == null)
                                  break Fail638;
                                if(true)
                                  break Success425;
                              }
                              term = term234;
                            }
                            Success426:
                            { 
                              if(cons68 == Simplify._consAnd_2)
                              { 
                                Fail639:
                                { 
                                  IStrategoTerm s_472 = null;
                                  IStrategoTerm t_472 = null;
                                  IStrategoTerm u_472 = null;
                                  IStrategoTerm arg313 = term.getSubterm(0);
                                  if(arg313.getTermType() != IStrategoTerm.APPL || Simplify._consGeq_2 != ((IStrategoAppl)arg313).getConstructor())
                                    break Fail639;
                                  s_472 = arg313.getSubterm(0);
                                  IStrategoTerm arg314 = arg313.getSubterm(1);
                                  if(arg314.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg314).getConstructor())
                                    break Fail639;
                                  t_472 = arg314.getSubterm(0);
                                  IStrategoTerm arg315 = term.getSubterm(1);
                                  if(arg315.getTermType() != IStrategoTerm.APPL || Simplify._consGt_2 != ((IStrategoAppl)arg315).getConstructor())
                                    break Fail639;
                                  if(arg315.getSubterm(0) != s_472 && !s_472.match(arg315.getSubterm(0)))
                                    break Fail639;
                                  IStrategoTerm arg316 = arg315.getSubterm(1);
                                  if(arg316.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg316).getConstructor())
                                    break Fail639;
                                  u_472 = arg316.getSubterm(0);
                                  term = termFactory.makeTuple(t_472, u_472);
                                  term = leq$S_0_0.instance.invoke(context, term);
                                  if(term == null)
                                    break Fail639;
                                  term = termFactory.makeAppl(Simplify._consGt_2, new IStrategoTerm[]{s_472, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{u_472})});
                                  term = t_480.invoke(context, term);
                                  if(term == null)
                                    break Fail639;
                                  if(true)
                                    break Success426;
                                }
                                term = term234;
                              }
                              Success427:
                              { 
                                if(cons68 == Simplify._consAnd_2)
                                { 
                                  Fail640:
                                  { 
                                    IStrategoTerm w_472 = null;
                                    IStrategoTerm x_472 = null;
                                    IStrategoTerm y_472 = null;
                                    IStrategoTerm z_472 = null;
                                    IStrategoTerm arg317 = term.getSubterm(0);
                                    if(arg317.getTermType() != IStrategoTerm.APPL || Simplify._consGt_2 != ((IStrategoAppl)arg317).getConstructor())
                                      break Fail640;
                                    w_472 = arg317.getSubterm(0);
                                    IStrategoTerm arg318 = arg317.getSubterm(1);
                                    if(arg318.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg318).getConstructor())
                                      break Fail640;
                                    x_472 = arg318.getSubterm(0);
                                    IStrategoTerm arg319 = term.getSubterm(1);
                                    if(arg319.getTermType() != IStrategoTerm.APPL || Simplify._consGt_2 != ((IStrategoAppl)arg319).getConstructor())
                                      break Fail640;
                                    if(arg319.getSubterm(0) != w_472 && !w_472.match(arg319.getSubterm(0)))
                                      break Fail640;
                                    IStrategoTerm arg320 = arg319.getSubterm(1);
                                    if(arg320.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg320).getConstructor())
                                      break Fail640;
                                    y_472 = arg320.getSubterm(0);
                                    term = termFactory.makeTuple(x_472, y_472);
                                    term = maxstring_0_0.instance.invoke(context, term);
                                    if(term == null)
                                      break Fail640;
                                    z_472 = term;
                                    term = s_480.instance.invoke(context, z_472, t_480);
                                    if(term == null)
                                      break Fail640;
                                    term = termFactory.makeAppl(Simplify._consGt_2, new IStrategoTerm[]{w_472, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{term})});
                                    term = t_480.invoke(context, term);
                                    if(term == null)
                                      break Fail640;
                                    if(true)
                                      break Success427;
                                  }
                                  term = term234;
                                }
                                Success428:
                                { 
                                  if(cons68 == Simplify._consAnd_2)
                                  { 
                                    Fail641:
                                    { 
                                      IStrategoTerm d_473 = null;
                                      IStrategoTerm e_473 = null;
                                      IStrategoTerm f_473 = null;
                                      IStrategoTerm g_473 = null;
                                      IStrategoTerm h_473 = null;
                                      IStrategoTerm arg321 = term.getSubterm(0);
                                      if(arg321.getTermType() != IStrategoTerm.APPL || Simplify._consAnd_2 != ((IStrategoAppl)arg321).getConstructor())
                                        break Fail641;
                                      d_473 = arg321.getSubterm(0);
                                      IStrategoTerm arg322 = arg321.getSubterm(1);
                                      if(arg322.getTermType() != IStrategoTerm.APPL || Simplify._consLt_2 != ((IStrategoAppl)arg322).getConstructor())
                                        break Fail641;
                                      e_473 = arg322.getSubterm(0);
                                      IStrategoTerm arg323 = arg322.getSubterm(1);
                                      if(arg323.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg323).getConstructor())
                                        break Fail641;
                                      f_473 = arg323.getSubterm(0);
                                      IStrategoTerm arg324 = term.getSubterm(1);
                                      if(arg324.getTermType() != IStrategoTerm.APPL || Simplify._consLt_2 != ((IStrategoAppl)arg324).getConstructor())
                                        break Fail641;
                                      if(arg324.getSubterm(0) != e_473 && !e_473.match(arg324.getSubterm(0)))
                                        break Fail641;
                                      IStrategoTerm arg325 = arg324.getSubterm(1);
                                      if(arg325.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg325).getConstructor())
                                        break Fail641;
                                      g_473 = arg325.getSubterm(0);
                                      term = termFactory.makeTuple(f_473, g_473);
                                      term = minstring_0_0.instance.invoke(context, term);
                                      if(term == null)
                                        break Fail641;
                                      h_473 = term;
                                      term = s_480.instance.invoke(context, h_473, t_480);
                                      if(term == null)
                                        break Fail641;
                                      term = termFactory.makeAppl(Simplify._consLt_2, new IStrategoTerm[]{e_473, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{term})});
                                      term = t_480.invoke(context, term);
                                      if(term == null)
                                        break Fail641;
                                      term = termFactory.makeAppl(Simplify._consAnd_2, new IStrategoTerm[]{d_473, term});
                                      term = t_480.invoke(context, term);
                                      if(term == null)
                                        break Fail641;
                                      if(true)
                                        break Success428;
                                    }
                                    term = term234;
                                  }
                                  Success429:
                                  { 
                                    if(cons68 == Simplify._consAnd_2)
                                    { 
                                      Fail642:
                                      { 
                                        IStrategoTerm n_473 = null;
                                        IStrategoTerm o_473 = null;
                                        IStrategoTerm p_473 = null;
                                        IStrategoTerm q_473 = null;
                                        IStrategoTerm arg326 = term.getSubterm(0);
                                        if(arg326.getTermType() != IStrategoTerm.APPL || Simplify._consAnd_2 != ((IStrategoAppl)arg326).getConstructor())
                                          break Fail642;
                                        n_473 = arg326.getSubterm(0);
                                        IStrategoTerm arg327 = arg326.getSubterm(1);
                                        if(arg327.getTermType() != IStrategoTerm.APPL || Simplify._consLt_2 != ((IStrategoAppl)arg327).getConstructor())
                                          break Fail642;
                                        o_473 = arg327.getSubterm(0);
                                        IStrategoTerm arg328 = arg327.getSubterm(1);
                                        if(arg328.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg328).getConstructor())
                                          break Fail642;
                                        p_473 = arg328.getSubterm(0);
                                        IStrategoTerm arg329 = term.getSubterm(1);
                                        if(arg329.getTermType() != IStrategoTerm.APPL || Simplify._consLeq_2 != ((IStrategoAppl)arg329).getConstructor())
                                          break Fail642;
                                        if(arg329.getSubterm(0) != o_473 && !o_473.match(arg329.getSubterm(0)))
                                          break Fail642;
                                        IStrategoTerm arg330 = arg329.getSubterm(1);
                                        if(arg330.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg330).getConstructor())
                                          break Fail642;
                                        q_473 = arg330.getSubterm(0);
                                        term = termFactory.makeTuple(p_473, q_473);
                                        term = gt$S_0_0.instance.invoke(context, term);
                                        if(term == null)
                                          break Fail642;
                                        term = termFactory.makeAppl(Simplify._consLeq_2, new IStrategoTerm[]{o_473, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{q_473})});
                                        term = t_480.invoke(context, term);
                                        if(term == null)
                                          break Fail642;
                                        term = termFactory.makeAppl(Simplify._consAnd_2, new IStrategoTerm[]{n_473, term});
                                        term = t_480.invoke(context, term);
                                        if(term == null)
                                          break Fail642;
                                        if(true)
                                          break Success429;
                                      }
                                      term = term234;
                                    }
                                    Success430:
                                    { 
                                      if(cons68 == Simplify._consAnd_2)
                                      { 
                                        Fail643:
                                        { 
                                          IStrategoTerm u_473 = null;
                                          IStrategoTerm v_473 = null;
                                          IStrategoTerm w_473 = null;
                                          IStrategoTerm x_473 = null;
                                          IStrategoTerm arg331 = term.getSubterm(0);
                                          if(arg331.getTermType() != IStrategoTerm.APPL || Simplify._consAnd_2 != ((IStrategoAppl)arg331).getConstructor())
                                            break Fail643;
                                          u_473 = arg331.getSubterm(0);
                                          IStrategoTerm arg332 = arg331.getSubterm(1);
                                          if(arg332.getTermType() != IStrategoTerm.APPL || Simplify._consLt_2 != ((IStrategoAppl)arg332).getConstructor())
                                            break Fail643;
                                          v_473 = arg332.getSubterm(0);
                                          IStrategoTerm arg333 = arg332.getSubterm(1);
                                          if(arg333.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg333).getConstructor())
                                            break Fail643;
                                          w_473 = arg333.getSubterm(0);
                                          IStrategoTerm arg334 = term.getSubterm(1);
                                          if(arg334.getTermType() != IStrategoTerm.APPL || Simplify._consLeq_2 != ((IStrategoAppl)arg334).getConstructor())
                                            break Fail643;
                                          if(arg334.getSubterm(0) != v_473 && !v_473.match(arg334.getSubterm(0)))
                                            break Fail643;
                                          IStrategoTerm arg335 = arg334.getSubterm(1);
                                          if(arg335.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg335).getConstructor())
                                            break Fail643;
                                          x_473 = arg335.getSubterm(0);
                                          term = termFactory.makeTuple(w_473, x_473);
                                          term = leq$S_0_0.instance.invoke(context, term);
                                          if(term == null)
                                            break Fail643;
                                          term = termFactory.makeAppl(Simplify._consLt_2, new IStrategoTerm[]{v_473, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{w_473})});
                                          term = t_480.invoke(context, term);
                                          if(term == null)
                                            break Fail643;
                                          term = termFactory.makeAppl(Simplify._consAnd_2, new IStrategoTerm[]{u_473, term});
                                          term = t_480.invoke(context, term);
                                          if(term == null)
                                            break Fail643;
                                          if(true)
                                            break Success430;
                                        }
                                        term = term234;
                                      }
                                      Success431:
                                      { 
                                        if(cons68 == Simplify._consAnd_2)
                                        { 
                                          Fail644:
                                          { 
                                            IStrategoTerm b_474 = null;
                                            IStrategoTerm c_474 = null;
                                            IStrategoTerm d_474 = null;
                                            IStrategoTerm e_474 = null;
                                            IStrategoTerm f_474 = null;
                                            IStrategoTerm arg336 = term.getSubterm(0);
                                            if(arg336.getTermType() != IStrategoTerm.APPL || Simplify._consAnd_2 != ((IStrategoAppl)arg336).getConstructor())
                                              break Fail644;
                                            b_474 = arg336.getSubterm(0);
                                            IStrategoTerm arg337 = arg336.getSubterm(1);
                                            if(arg337.getTermType() != IStrategoTerm.APPL || Simplify._consLeq_2 != ((IStrategoAppl)arg337).getConstructor())
                                              break Fail644;
                                            c_474 = arg337.getSubterm(0);
                                            IStrategoTerm arg338 = arg337.getSubterm(1);
                                            if(arg338.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg338).getConstructor())
                                              break Fail644;
                                            d_474 = arg338.getSubterm(0);
                                            IStrategoTerm arg339 = term.getSubterm(1);
                                            if(arg339.getTermType() != IStrategoTerm.APPL || Simplify._consLeq_2 != ((IStrategoAppl)arg339).getConstructor())
                                              break Fail644;
                                            if(arg339.getSubterm(0) != c_474 && !c_474.match(arg339.getSubterm(0)))
                                              break Fail644;
                                            IStrategoTerm arg340 = arg339.getSubterm(1);
                                            if(arg340.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg340).getConstructor())
                                              break Fail644;
                                            e_474 = arg340.getSubterm(0);
                                            term = termFactory.makeTuple(d_474, e_474);
                                            term = minstring_0_0.instance.invoke(context, term);
                                            if(term == null)
                                              break Fail644;
                                            f_474 = term;
                                            term = s_480.instance.invoke(context, f_474, t_480);
                                            if(term == null)
                                              break Fail644;
                                            term = termFactory.makeAppl(Simplify._consLeq_2, new IStrategoTerm[]{c_474, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{term})});
                                            term = t_480.invoke(context, term);
                                            if(term == null)
                                              break Fail644;
                                            term = termFactory.makeAppl(Simplify._consAnd_2, new IStrategoTerm[]{b_474, term});
                                            term = t_480.invoke(context, term);
                                            if(term == null)
                                              break Fail644;
                                            if(true)
                                              break Success431;
                                          }
                                          term = term234;
                                        }
                                        Success432:
                                        { 
                                          if(cons68 == Simplify._consAnd_2)
                                          { 
                                            Fail645:
                                            { 
                                              IStrategoTerm m_474 = null;
                                              IStrategoTerm n_474 = null;
                                              IStrategoTerm o_474 = null;
                                              IStrategoTerm arg341 = term.getSubterm(0);
                                              if(arg341.getTermType() != IStrategoTerm.APPL || Simplify._consAnd_2 != ((IStrategoAppl)arg341).getConstructor())
                                                break Fail645;
                                              IStrategoTerm arg342 = arg341.getSubterm(1);
                                              if(arg342.getTermType() != IStrategoTerm.APPL || Simplify._consEqu_2 != ((IStrategoAppl)arg342).getConstructor())
                                                break Fail645;
                                              m_474 = arg342.getSubterm(0);
                                              IStrategoTerm arg343 = arg342.getSubterm(1);
                                              if(arg343.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg343).getConstructor())
                                                break Fail645;
                                              n_474 = arg343.getSubterm(0);
                                              IStrategoTerm arg344 = term.getSubterm(1);
                                              if(arg344.getTermType() != IStrategoTerm.APPL || Simplify._consEqu_2 != ((IStrategoAppl)arg344).getConstructor())
                                                break Fail645;
                                              if(arg344.getSubterm(0) != m_474 && !m_474.match(arg344.getSubterm(0)))
                                                break Fail645;
                                              IStrategoTerm arg345 = arg344.getSubterm(1);
                                              if(arg345.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg345).getConstructor())
                                                break Fail645;
                                              o_474 = arg345.getSubterm(0);
                                              term = termFactory.makeTuple(n_474, o_474);
                                              IStrategoTerm term250 = term;
                                              Success433:
                                              { 
                                                Fail646:
                                                { 
                                                  term = eq_0_0.instance.invoke(context, term);
                                                  if(term == null)
                                                    break Fail646;
                                                  { 
                                                    if(true)
                                                      break Fail645;
                                                    if(true)
                                                      break Success433;
                                                  }
                                                }
                                                term = term250;
                                              }
                                              term = Simplify.constFalse0;
                                              if(true)
                                                break Success432;
                                            }
                                            term = term234;
                                          }
                                          Success434:
                                          { 
                                            if(cons68 == Simplify._consAnd_2)
                                            { 
                                              Fail647:
                                              { 
                                                IStrategoTerm q_474 = null;
                                                IStrategoTerm r_474 = null;
                                                IStrategoTerm s_474 = null;
                                                IStrategoTerm arg346 = term.getSubterm(0);
                                                if(arg346.getTermType() != IStrategoTerm.APPL || Simplify._consAnd_2 != ((IStrategoAppl)arg346).getConstructor())
                                                  break Fail647;
                                                q_474 = arg346.getSubterm(0);
                                                IStrategoTerm arg347 = arg346.getSubterm(1);
                                                if(arg347.getTermType() != IStrategoTerm.APPL || Simplify._consEqu_2 != ((IStrategoAppl)arg347).getConstructor())
                                                  break Fail647;
                                                r_474 = arg347.getSubterm(0);
                                                IStrategoTerm arg348 = arg347.getSubterm(1);
                                                if(arg348.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg348).getConstructor())
                                                  break Fail647;
                                                s_474 = arg348.getSubterm(0);
                                                IStrategoTerm arg349 = term.getSubterm(1);
                                                if(arg349.getTermType() != IStrategoTerm.APPL || Simplify._consEqu_2 != ((IStrategoAppl)arg349).getConstructor())
                                                  break Fail647;
                                                if(arg349.getSubterm(0) != r_474 && !r_474.match(arg349.getSubterm(0)))
                                                  break Fail647;
                                                IStrategoTerm arg350 = arg349.getSubterm(1);
                                                if(arg350.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg350).getConstructor())
                                                  break Fail647;
                                                if(arg350.getSubterm(0) != s_474 && !s_474.match(arg350.getSubterm(0)))
                                                  break Fail647;
                                                term = termFactory.makeAppl(Simplify._consEqu_2, new IStrategoTerm[]{r_474, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{s_474})});
                                                term = t_480.invoke(context, term);
                                                if(term == null)
                                                  break Fail647;
                                                term = termFactory.makeAppl(Simplify._consAnd_2, new IStrategoTerm[]{q_474, term});
                                                term = t_480.invoke(context, term);
                                                if(term == null)
                                                  break Fail647;
                                                if(true)
                                                  break Success434;
                                              }
                                              term = term234;
                                            }
                                            Success435:
                                            { 
                                              if(cons68 == Simplify._consAnd_2)
                                              { 
                                                Fail648:
                                                { 
                                                  IStrategoTerm v_474 = null;
                                                  IStrategoTerm w_474 = null;
                                                  IStrategoTerm x_474 = null;
                                                  IStrategoTerm y_474 = null;
                                                  IStrategoTerm z_474 = null;
                                                  IStrategoTerm arg351 = term.getSubterm(0);
                                                  if(arg351.getTermType() != IStrategoTerm.APPL || Simplify._consAnd_2 != ((IStrategoAppl)arg351).getConstructor())
                                                    break Fail648;
                                                  v_474 = arg351.getSubterm(0);
                                                  IStrategoTerm arg352 = arg351.getSubterm(1);
                                                  if(arg352.getTermType() != IStrategoTerm.APPL || Simplify._consGeq_2 != ((IStrategoAppl)arg352).getConstructor())
                                                    break Fail648;
                                                  w_474 = arg352.getSubterm(0);
                                                  IStrategoTerm arg353 = arg352.getSubterm(1);
                                                  if(arg353.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg353).getConstructor())
                                                    break Fail648;
                                                  x_474 = arg353.getSubterm(0);
                                                  IStrategoTerm arg354 = term.getSubterm(1);
                                                  if(arg354.getTermType() != IStrategoTerm.APPL || Simplify._consGeq_2 != ((IStrategoAppl)arg354).getConstructor())
                                                    break Fail648;
                                                  if(arg354.getSubterm(0) != w_474 && !w_474.match(arg354.getSubterm(0)))
                                                    break Fail648;
                                                  IStrategoTerm arg355 = arg354.getSubterm(1);
                                                  if(arg355.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg355).getConstructor())
                                                    break Fail648;
                                                  y_474 = arg355.getSubterm(0);
                                                  term = termFactory.makeTuple(x_474, y_474);
                                                  term = maxstring_0_0.instance.invoke(context, term);
                                                  if(term == null)
                                                    break Fail648;
                                                  z_474 = term;
                                                  term = s_480.instance.invoke(context, z_474, t_480);
                                                  if(term == null)
                                                    break Fail648;
                                                  term = termFactory.makeAppl(Simplify._consGeq_2, new IStrategoTerm[]{w_474, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{term})});
                                                  term = t_480.invoke(context, term);
                                                  if(term == null)
                                                    break Fail648;
                                                  term = termFactory.makeAppl(Simplify._consAnd_2, new IStrategoTerm[]{v_474, term});
                                                  term = t_480.invoke(context, term);
                                                  if(term == null)
                                                    break Fail648;
                                                  if(true)
                                                    break Success435;
                                                }
                                                term = term234;
                                              }
                                              Success436:
                                              { 
                                                if(cons68 == Simplify._consAnd_2)
                                                { 
                                                  Fail649:
                                                  { 
                                                    IStrategoTerm f_475 = null;
                                                    IStrategoTerm g_475 = null;
                                                    IStrategoTerm h_475 = null;
                                                    IStrategoTerm i_475 = null;
                                                    IStrategoTerm arg356 = term.getSubterm(0);
                                                    if(arg356.getTermType() != IStrategoTerm.APPL || Simplify._consAnd_2 != ((IStrategoAppl)arg356).getConstructor())
                                                      break Fail649;
                                                    f_475 = arg356.getSubterm(0);
                                                    IStrategoTerm arg357 = arg356.getSubterm(1);
                                                    if(arg357.getTermType() != IStrategoTerm.APPL || Simplify._consGeq_2 != ((IStrategoAppl)arg357).getConstructor())
                                                      break Fail649;
                                                    g_475 = arg357.getSubterm(0);
                                                    IStrategoTerm arg358 = arg357.getSubterm(1);
                                                    if(arg358.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg358).getConstructor())
                                                      break Fail649;
                                                    h_475 = arg358.getSubterm(0);
                                                    IStrategoTerm arg359 = term.getSubterm(1);
                                                    if(arg359.getTermType() != IStrategoTerm.APPL || Simplify._consGt_2 != ((IStrategoAppl)arg359).getConstructor())
                                                      break Fail649;
                                                    if(arg359.getSubterm(0) != g_475 && !g_475.match(arg359.getSubterm(0)))
                                                      break Fail649;
                                                    IStrategoTerm arg360 = arg359.getSubterm(1);
                                                    if(arg360.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg360).getConstructor())
                                                      break Fail649;
                                                    i_475 = arg360.getSubterm(0);
                                                    term = termFactory.makeTuple(h_475, i_475);
                                                    term = gt$S_0_0.instance.invoke(context, term);
                                                    if(term == null)
                                                      break Fail649;
                                                    term = termFactory.makeAppl(Simplify._consGeq_2, new IStrategoTerm[]{g_475, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{h_475})});
                                                    term = t_480.invoke(context, term);
                                                    if(term == null)
                                                      break Fail649;
                                                    term = termFactory.makeAppl(Simplify._consAnd_2, new IStrategoTerm[]{f_475, term});
                                                    term = t_480.invoke(context, term);
                                                    if(term == null)
                                                      break Fail649;
                                                    if(true)
                                                      break Success436;
                                                  }
                                                  term = term234;
                                                }
                                                canonical_0_0_fragment_2 canonical_0_0_fragment_20 = new canonical_0_0_fragment_2();
                                                canonical_0_0_fragment_20.t_480 = t_480;
                                                term = canonical_0_0_fragment_20.invoke(context, term);
                                                if(term == null)
                                                  break Fail619;
                                              }
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class canonical_0_0_fragment_2 extends Strategy 
  { 
    Strategy t_480;

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      ITermFactory termFactory = context.getFactory();
      Fail650:
      { 
        IStrategoTerm term254 = term;
        IStrategoConstructor cons69 = term.getTermType() == IStrategoTerm.APPL ? ((IStrategoAppl)term).getConstructor() : null;
        Success437:
        { 
          if(cons69 == Simplify._consAnd_2)
          { 
            Fail651:
            { 
              IStrategoTerm m_475 = null;
              IStrategoTerm n_475 = null;
              IStrategoTerm o_475 = null;
              IStrategoTerm p_475 = null;
              IStrategoTerm arg361 = term.getSubterm(0);
              if(arg361.getTermType() != IStrategoTerm.APPL || Simplify._consAnd_2 != ((IStrategoAppl)arg361).getConstructor())
                break Fail651;
              m_475 = arg361.getSubterm(0);
              IStrategoTerm arg362 = arg361.getSubterm(1);
              if(arg362.getTermType() != IStrategoTerm.APPL || Simplify._consGeq_2 != ((IStrategoAppl)arg362).getConstructor())
                break Fail651;
              n_475 = arg362.getSubterm(0);
              IStrategoTerm arg363 = arg362.getSubterm(1);
              if(arg363.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg363).getConstructor())
                break Fail651;
              o_475 = arg363.getSubterm(0);
              IStrategoTerm arg364 = term.getSubterm(1);
              if(arg364.getTermType() != IStrategoTerm.APPL || Simplify._consGt_2 != ((IStrategoAppl)arg364).getConstructor())
                break Fail651;
              if(arg364.getSubterm(0) != n_475 && !n_475.match(arg364.getSubterm(0)))
                break Fail651;
              IStrategoTerm arg365 = arg364.getSubterm(1);
              if(arg365.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg365).getConstructor())
                break Fail651;
              p_475 = arg365.getSubterm(0);
              term = termFactory.makeTuple(o_475, p_475);
              term = leq$S_0_0.instance.invoke(context, term);
              if(term == null)
                break Fail651;
              term = termFactory.makeAppl(Simplify._consGt_2, new IStrategoTerm[]{n_475, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{p_475})});
              term = t_480.invoke(context, term);
              if(term == null)
                break Fail651;
              term = termFactory.makeAppl(Simplify._consAnd_2, new IStrategoTerm[]{m_475, term});
              term = t_480.invoke(context, term);
              if(term == null)
                break Fail651;
              if(true)
                break Success437;
            }
            term = term254;
          }
          Success438:
          { 
            if(cons69 == Simplify._consAnd_2)
            { 
              Fail652:
              { 
                IStrategoTerm t_475 = null;
                IStrategoTerm u_475 = null;
                IStrategoTerm v_475 = null;
                IStrategoTerm w_475 = null;
                IStrategoTerm x_475 = null;
                IStrategoTerm arg366 = term.getSubterm(0);
                if(arg366.getTermType() != IStrategoTerm.APPL || Simplify._consAnd_2 != ((IStrategoAppl)arg366).getConstructor())
                  break Fail652;
                t_475 = arg366.getSubterm(0);
                IStrategoTerm arg367 = arg366.getSubterm(1);
                if(arg367.getTermType() != IStrategoTerm.APPL || Simplify._consGt_2 != ((IStrategoAppl)arg367).getConstructor())
                  break Fail652;
                u_475 = arg367.getSubterm(0);
                IStrategoTerm arg368 = arg367.getSubterm(1);
                if(arg368.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg368).getConstructor())
                  break Fail652;
                v_475 = arg368.getSubterm(0);
                IStrategoTerm arg369 = term.getSubterm(1);
                if(arg369.getTermType() != IStrategoTerm.APPL || Simplify._consGt_2 != ((IStrategoAppl)arg369).getConstructor())
                  break Fail652;
                if(arg369.getSubterm(0) != u_475 && !u_475.match(arg369.getSubterm(0)))
                  break Fail652;
                IStrategoTerm arg370 = arg369.getSubterm(1);
                if(arg370.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg370).getConstructor())
                  break Fail652;
                w_475 = arg370.getSubterm(0);
                term = termFactory.makeTuple(v_475, w_475);
                term = maxstring_0_0.instance.invoke(context, term);
                if(term == null)
                  break Fail652;
                x_475 = term;
                term = s_480.instance.invoke(context, x_475, t_480);
                if(term == null)
                  break Fail652;
                term = termFactory.makeAppl(Simplify._consGt_2, new IStrategoTerm[]{u_475, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{term})});
                term = t_480.invoke(context, term);
                if(term == null)
                  break Fail652;
                term = termFactory.makeAppl(Simplify._consAnd_2, new IStrategoTerm[]{t_475, term});
                term = t_480.invoke(context, term);
                if(term == null)
                  break Fail652;
                if(true)
                  break Success438;
              }
              term = term254;
            }
            Success439:
            { 
              if(cons69 == Simplify._consOr_2)
              { 
                Fail653:
                { 
                  IStrategoTerm d_476 = null;
                  IStrategoTerm e_476 = null;
                  IStrategoTerm f_476 = null;
                  IStrategoTerm g_476 = null;
                  IStrategoTerm arg371 = term.getSubterm(0);
                  if(arg371.getTermType() != IStrategoTerm.APPL || Simplify._consLt_2 != ((IStrategoAppl)arg371).getConstructor())
                    break Fail653;
                  d_476 = arg371.getSubterm(0);
                  IStrategoTerm arg372 = arg371.getSubterm(1);
                  if(arg372.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg372).getConstructor())
                    break Fail653;
                  e_476 = arg372.getSubterm(0);
                  IStrategoTerm arg373 = term.getSubterm(1);
                  if(arg373.getTermType() != IStrategoTerm.APPL || Simplify._consLt_2 != ((IStrategoAppl)arg373).getConstructor())
                    break Fail653;
                  if(arg373.getSubterm(0) != d_476 && !d_476.match(arg373.getSubterm(0)))
                    break Fail653;
                  IStrategoTerm arg374 = arg373.getSubterm(1);
                  if(arg374.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg374).getConstructor())
                    break Fail653;
                  f_476 = arg374.getSubterm(0);
                  term = termFactory.makeTuple(e_476, f_476);
                  term = maxstring_0_0.instance.invoke(context, term);
                  if(term == null)
                    break Fail653;
                  g_476 = term;
                  term = s_480.instance.invoke(context, g_476, t_480);
                  if(term == null)
                    break Fail653;
                  term = termFactory.makeAppl(Simplify._consLt_2, new IStrategoTerm[]{d_476, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{term})});
                  term = t_480.invoke(context, term);
                  if(term == null)
                    break Fail653;
                  if(true)
                    break Success439;
                }
                term = term254;
              }
              Success440:
              { 
                if(cons69 == Simplify._consOr_2)
                { 
                  Fail654:
                  { 
                    IStrategoTerm k_476 = null;
                    IStrategoTerm l_476 = null;
                    IStrategoTerm m_476 = null;
                    IStrategoTerm arg375 = term.getSubterm(0);
                    if(arg375.getTermType() != IStrategoTerm.APPL || Simplify._consLt_2 != ((IStrategoAppl)arg375).getConstructor())
                      break Fail654;
                    k_476 = arg375.getSubterm(0);
                    IStrategoTerm arg376 = arg375.getSubterm(1);
                    if(arg376.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg376).getConstructor())
                      break Fail654;
                    l_476 = arg376.getSubterm(0);
                    IStrategoTerm arg377 = term.getSubterm(1);
                    if(arg377.getTermType() != IStrategoTerm.APPL || Simplify._consLeq_2 != ((IStrategoAppl)arg377).getConstructor())
                      break Fail654;
                    if(arg377.getSubterm(0) != k_476 && !k_476.match(arg377.getSubterm(0)))
                      break Fail654;
                    IStrategoTerm arg378 = arg377.getSubterm(1);
                    if(arg378.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg378).getConstructor())
                      break Fail654;
                    m_476 = arg378.getSubterm(0);
                    term = termFactory.makeTuple(l_476, m_476);
                    term = leq$S_0_0.instance.invoke(context, term);
                    if(term == null)
                      break Fail654;
                    term = termFactory.makeAppl(Simplify._consLeq_2, new IStrategoTerm[]{k_476, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{m_476})});
                    term = t_480.invoke(context, term);
                    if(term == null)
                      break Fail654;
                    if(true)
                      break Success440;
                  }
                  term = term254;
                }
                Success441:
                { 
                  if(cons69 == Simplify._consOr_2)
                  { 
                    Fail655:
                    { 
                      IStrategoTerm o_476 = null;
                      IStrategoTerm p_476 = null;
                      IStrategoTerm q_476 = null;
                      IStrategoTerm arg379 = term.getSubterm(0);
                      if(arg379.getTermType() != IStrategoTerm.APPL || Simplify._consLt_2 != ((IStrategoAppl)arg379).getConstructor())
                        break Fail655;
                      o_476 = arg379.getSubterm(0);
                      IStrategoTerm arg380 = arg379.getSubterm(1);
                      if(arg380.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg380).getConstructor())
                        break Fail655;
                      p_476 = arg380.getSubterm(0);
                      IStrategoTerm arg381 = term.getSubterm(1);
                      if(arg381.getTermType() != IStrategoTerm.APPL || Simplify._consLeq_2 != ((IStrategoAppl)arg381).getConstructor())
                        break Fail655;
                      if(arg381.getSubterm(0) != o_476 && !o_476.match(arg381.getSubterm(0)))
                        break Fail655;
                      IStrategoTerm arg382 = arg381.getSubterm(1);
                      if(arg382.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg382).getConstructor())
                        break Fail655;
                      q_476 = arg382.getSubterm(0);
                      term = termFactory.makeTuple(p_476, q_476);
                      term = gt$S_0_0.instance.invoke(context, term);
                      if(term == null)
                        break Fail655;
                      term = termFactory.makeAppl(Simplify._consLt_2, new IStrategoTerm[]{o_476, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{p_476})});
                      term = t_480.invoke(context, term);
                      if(term == null)
                        break Fail655;
                      if(true)
                        break Success441;
                    }
                    term = term254;
                  }
                  Success442:
                  { 
                    if(cons69 == Simplify._consOr_2)
                    { 
                      Fail656:
                      { 
                        IStrategoTerm s_476 = null;
                        IStrategoTerm t_476 = null;
                        IStrategoTerm u_476 = null;
                        IStrategoTerm v_476 = null;
                        IStrategoTerm arg383 = term.getSubterm(0);
                        if(arg383.getTermType() != IStrategoTerm.APPL || Simplify._consLeq_2 != ((IStrategoAppl)arg383).getConstructor())
                          break Fail656;
                        s_476 = arg383.getSubterm(0);
                        IStrategoTerm arg384 = arg383.getSubterm(1);
                        if(arg384.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg384).getConstructor())
                          break Fail656;
                        t_476 = arg384.getSubterm(0);
                        IStrategoTerm arg385 = term.getSubterm(1);
                        if(arg385.getTermType() != IStrategoTerm.APPL || Simplify._consLeq_2 != ((IStrategoAppl)arg385).getConstructor())
                          break Fail656;
                        if(arg385.getSubterm(0) != s_476 && !s_476.match(arg385.getSubterm(0)))
                          break Fail656;
                        IStrategoTerm arg386 = arg385.getSubterm(1);
                        if(arg386.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg386).getConstructor())
                          break Fail656;
                        u_476 = arg386.getSubterm(0);
                        term = termFactory.makeTuple(t_476, u_476);
                        term = maxstring_0_0.instance.invoke(context, term);
                        if(term == null)
                          break Fail656;
                        v_476 = term;
                        term = s_480.instance.invoke(context, v_476, t_480);
                        if(term == null)
                          break Fail656;
                        term = termFactory.makeAppl(Simplify._consLeq_2, new IStrategoTerm[]{s_476, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{term})});
                        term = t_480.invoke(context, term);
                        if(term == null)
                          break Fail656;
                        if(true)
                          break Success442;
                      }
                      term = term254;
                    }
                    Success443:
                    { 
                      if(cons69 == Simplify._consOr_2)
                      { 
                        Fail657:
                        { 
                          IStrategoTerm z_476 = null;
                          IStrategoTerm a_477 = null;
                          IStrategoTerm arg387 = term.getSubterm(0);
                          if(arg387.getTermType() != IStrategoTerm.APPL || Simplify._consEqu_2 != ((IStrategoAppl)arg387).getConstructor())
                            break Fail657;
                          z_476 = arg387.getSubterm(0);
                          IStrategoTerm arg388 = arg387.getSubterm(1);
                          if(arg388.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg388).getConstructor())
                            break Fail657;
                          a_477 = arg388.getSubterm(0);
                          IStrategoTerm arg389 = term.getSubterm(1);
                          if(arg389.getTermType() != IStrategoTerm.APPL || Simplify._consEqu_2 != ((IStrategoAppl)arg389).getConstructor())
                            break Fail657;
                          if(arg389.getSubterm(0) != z_476 && !z_476.match(arg389.getSubterm(0)))
                            break Fail657;
                          IStrategoTerm arg390 = arg389.getSubterm(1);
                          if(arg390.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg390).getConstructor())
                            break Fail657;
                          if(arg390.getSubterm(0) != a_477 && !a_477.match(arg390.getSubterm(0)))
                            break Fail657;
                          term = termFactory.makeAppl(Simplify._consEqu_2, new IStrategoTerm[]{z_476, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{a_477})});
                          term = t_480.invoke(context, term);
                          if(term == null)
                            break Fail657;
                          if(true)
                            break Success443;
                        }
                        term = term254;
                      }
                      Success444:
                      { 
                        if(cons69 == Simplify._consOr_2)
                        { 
                          Fail658:
                          { 
                            IStrategoTerm b_477 = null;
                            IStrategoTerm c_477 = null;
                            IStrategoTerm d_477 = null;
                            IStrategoTerm e_477 = null;
                            IStrategoTerm arg391 = term.getSubterm(0);
                            if(arg391.getTermType() != IStrategoTerm.APPL || Simplify._consGeq_2 != ((IStrategoAppl)arg391).getConstructor())
                              break Fail658;
                            b_477 = arg391.getSubterm(0);
                            IStrategoTerm arg392 = arg391.getSubterm(1);
                            if(arg392.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg392).getConstructor())
                              break Fail658;
                            c_477 = arg392.getSubterm(0);
                            IStrategoTerm arg393 = term.getSubterm(1);
                            if(arg393.getTermType() != IStrategoTerm.APPL || Simplify._consGeq_2 != ((IStrategoAppl)arg393).getConstructor())
                              break Fail658;
                            if(arg393.getSubterm(0) != b_477 && !b_477.match(arg393.getSubterm(0)))
                              break Fail658;
                            IStrategoTerm arg394 = arg393.getSubterm(1);
                            if(arg394.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg394).getConstructor())
                              break Fail658;
                            d_477 = arg394.getSubterm(0);
                            term = termFactory.makeTuple(c_477, d_477);
                            term = minstring_0_0.instance.invoke(context, term);
                            if(term == null)
                              break Fail658;
                            e_477 = term;
                            term = s_480.instance.invoke(context, e_477, t_480);
                            if(term == null)
                              break Fail658;
                            term = termFactory.makeAppl(Simplify._consGeq_2, new IStrategoTerm[]{b_477, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{term})});
                            term = t_480.invoke(context, term);
                            if(term == null)
                              break Fail658;
                            if(true)
                              break Success444;
                          }
                          term = term254;
                        }
                        Success445:
                        { 
                          if(cons69 == Simplify._consOr_2)
                          { 
                            Fail659:
                            { 
                              IStrategoTerm i_477 = null;
                              IStrategoTerm j_477 = null;
                              IStrategoTerm k_477 = null;
                              IStrategoTerm arg395 = term.getSubterm(0);
                              if(arg395.getTermType() != IStrategoTerm.APPL || Simplify._consGeq_2 != ((IStrategoAppl)arg395).getConstructor())
                                break Fail659;
                              i_477 = arg395.getSubterm(0);
                              IStrategoTerm arg396 = arg395.getSubterm(1);
                              if(arg396.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg396).getConstructor())
                                break Fail659;
                              j_477 = arg396.getSubterm(0);
                              IStrategoTerm arg397 = term.getSubterm(1);
                              if(arg397.getTermType() != IStrategoTerm.APPL || Simplify._consGt_2 != ((IStrategoAppl)arg397).getConstructor())
                                break Fail659;
                              if(arg397.getSubterm(0) != i_477 && !i_477.match(arg397.getSubterm(0)))
                                break Fail659;
                              IStrategoTerm arg398 = arg397.getSubterm(1);
                              if(arg398.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg398).getConstructor())
                                break Fail659;
                              k_477 = arg398.getSubterm(0);
                              term = termFactory.makeTuple(j_477, k_477);
                              term = leq$S_0_0.instance.invoke(context, term);
                              if(term == null)
                                break Fail659;
                              term = termFactory.makeAppl(Simplify._consGeq_2, new IStrategoTerm[]{i_477, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{j_477})});
                              term = t_480.invoke(context, term);
                              if(term == null)
                                break Fail659;
                              if(true)
                                break Success445;
                            }
                            term = term254;
                          }
                          Success446:
                          { 
                            if(cons69 == Simplify._consOr_2)
                            { 
                              Fail660:
                              { 
                                IStrategoTerm m_477 = null;
                                IStrategoTerm n_477 = null;
                                IStrategoTerm o_477 = null;
                                IStrategoTerm arg399 = term.getSubterm(0);
                                if(arg399.getTermType() != IStrategoTerm.APPL || Simplify._consGeq_2 != ((IStrategoAppl)arg399).getConstructor())
                                  break Fail660;
                                m_477 = arg399.getSubterm(0);
                                IStrategoTerm arg400 = arg399.getSubterm(1);
                                if(arg400.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg400).getConstructor())
                                  break Fail660;
                                n_477 = arg400.getSubterm(0);
                                IStrategoTerm arg401 = term.getSubterm(1);
                                if(arg401.getTermType() != IStrategoTerm.APPL || Simplify._consGt_2 != ((IStrategoAppl)arg401).getConstructor())
                                  break Fail660;
                                if(arg401.getSubterm(0) != m_477 && !m_477.match(arg401.getSubterm(0)))
                                  break Fail660;
                                IStrategoTerm arg402 = arg401.getSubterm(1);
                                if(arg402.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg402).getConstructor())
                                  break Fail660;
                                o_477 = arg402.getSubterm(0);
                                term = termFactory.makeTuple(n_477, o_477);
                                term = gt$S_0_0.instance.invoke(context, term);
                                if(term == null)
                                  break Fail660;
                                term = termFactory.makeAppl(Simplify._consGt_2, new IStrategoTerm[]{m_477, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{o_477})});
                                term = t_480.invoke(context, term);
                                if(term == null)
                                  break Fail660;
                                if(true)
                                  break Success446;
                              }
                              term = term254;
                            }
                            Success447:
                            { 
                              if(cons69 == Simplify._consOr_2)
                              { 
                                Fail661:
                                { 
                                  IStrategoTerm q_477 = null;
                                  IStrategoTerm r_477 = null;
                                  IStrategoTerm s_477 = null;
                                  IStrategoTerm t_477 = null;
                                  IStrategoTerm arg403 = term.getSubterm(0);
                                  if(arg403.getTermType() != IStrategoTerm.APPL || Simplify._consGt_2 != ((IStrategoAppl)arg403).getConstructor())
                                    break Fail661;
                                  q_477 = arg403.getSubterm(0);
                                  IStrategoTerm arg404 = arg403.getSubterm(1);
                                  if(arg404.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg404).getConstructor())
                                    break Fail661;
                                  r_477 = arg404.getSubterm(0);
                                  IStrategoTerm arg405 = term.getSubterm(1);
                                  if(arg405.getTermType() != IStrategoTerm.APPL || Simplify._consGt_2 != ((IStrategoAppl)arg405).getConstructor())
                                    break Fail661;
                                  if(arg405.getSubterm(0) != q_477 && !q_477.match(arg405.getSubterm(0)))
                                    break Fail661;
                                  IStrategoTerm arg406 = arg405.getSubterm(1);
                                  if(arg406.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg406).getConstructor())
                                    break Fail661;
                                  s_477 = arg406.getSubterm(0);
                                  term = termFactory.makeTuple(r_477, s_477);
                                  term = minstring_0_0.instance.invoke(context, term);
                                  if(term == null)
                                    break Fail661;
                                  t_477 = term;
                                  term = s_480.instance.invoke(context, t_477, t_480);
                                  if(term == null)
                                    break Fail661;
                                  term = termFactory.makeAppl(Simplify._consGt_2, new IStrategoTerm[]{q_477, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{term})});
                                  term = t_480.invoke(context, term);
                                  if(term == null)
                                    break Fail661;
                                  if(true)
                                    break Success447;
                                }
                                term = term254;
                              }
                              Success448:
                              { 
                                if(cons69 == Simplify._consOr_2)
                                { 
                                  Fail662:
                                  { 
                                    IStrategoTerm x_477 = null;
                                    IStrategoTerm y_477 = null;
                                    IStrategoTerm z_477 = null;
                                    IStrategoTerm a_478 = null;
                                    IStrategoTerm b_478 = null;
                                    IStrategoTerm arg407 = term.getSubterm(0);
                                    if(arg407.getTermType() != IStrategoTerm.APPL || Simplify._consOr_2 != ((IStrategoAppl)arg407).getConstructor())
                                      break Fail662;
                                    x_477 = arg407.getSubterm(0);
                                    IStrategoTerm arg408 = arg407.getSubterm(1);
                                    if(arg408.getTermType() != IStrategoTerm.APPL || Simplify._consLt_2 != ((IStrategoAppl)arg408).getConstructor())
                                      break Fail662;
                                    y_477 = arg408.getSubterm(0);
                                    IStrategoTerm arg409 = arg408.getSubterm(1);
                                    if(arg409.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg409).getConstructor())
                                      break Fail662;
                                    z_477 = arg409.getSubterm(0);
                                    IStrategoTerm arg410 = term.getSubterm(1);
                                    if(arg410.getTermType() != IStrategoTerm.APPL || Simplify._consLt_2 != ((IStrategoAppl)arg410).getConstructor())
                                      break Fail662;
                                    if(arg410.getSubterm(0) != y_477 && !y_477.match(arg410.getSubterm(0)))
                                      break Fail662;
                                    IStrategoTerm arg411 = arg410.getSubterm(1);
                                    if(arg411.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg411).getConstructor())
                                      break Fail662;
                                    a_478 = arg411.getSubterm(0);
                                    term = termFactory.makeTuple(z_477, a_478);
                                    term = maxstring_0_0.instance.invoke(context, term);
                                    if(term == null)
                                      break Fail662;
                                    b_478 = term;
                                    term = s_480.instance.invoke(context, b_478, t_480);
                                    if(term == null)
                                      break Fail662;
                                    term = termFactory.makeAppl(Simplify._consLt_2, new IStrategoTerm[]{y_477, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{term})});
                                    term = t_480.invoke(context, term);
                                    if(term == null)
                                      break Fail662;
                                    term = termFactory.makeAppl(Simplify._consOr_2, new IStrategoTerm[]{x_477, term});
                                    term = t_480.invoke(context, term);
                                    if(term == null)
                                      break Fail662;
                                    if(true)
                                      break Success448;
                                  }
                                  term = term254;
                                }
                                Success449:
                                { 
                                  if(cons69 == Simplify._consOr_2)
                                  { 
                                    Fail663:
                                    { 
                                      IStrategoTerm h_478 = null;
                                      IStrategoTerm i_478 = null;
                                      IStrategoTerm j_478 = null;
                                      IStrategoTerm k_478 = null;
                                      IStrategoTerm arg412 = term.getSubterm(0);
                                      if(arg412.getTermType() != IStrategoTerm.APPL || Simplify._consOr_2 != ((IStrategoAppl)arg412).getConstructor())
                                        break Fail663;
                                      h_478 = arg412.getSubterm(0);
                                      IStrategoTerm arg413 = arg412.getSubterm(1);
                                      if(arg413.getTermType() != IStrategoTerm.APPL || Simplify._consLt_2 != ((IStrategoAppl)arg413).getConstructor())
                                        break Fail663;
                                      i_478 = arg413.getSubterm(0);
                                      IStrategoTerm arg414 = arg413.getSubterm(1);
                                      if(arg414.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg414).getConstructor())
                                        break Fail663;
                                      j_478 = arg414.getSubterm(0);
                                      IStrategoTerm arg415 = term.getSubterm(1);
                                      if(arg415.getTermType() != IStrategoTerm.APPL || Simplify._consLeq_2 != ((IStrategoAppl)arg415).getConstructor())
                                        break Fail663;
                                      if(arg415.getSubterm(0) != i_478 && !i_478.match(arg415.getSubterm(0)))
                                        break Fail663;
                                      IStrategoTerm arg416 = arg415.getSubterm(1);
                                      if(arg416.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg416).getConstructor())
                                        break Fail663;
                                      k_478 = arg416.getSubterm(0);
                                      term = termFactory.makeTuple(j_478, k_478);
                                      term = leq$S_0_0.instance.invoke(context, term);
                                      if(term == null)
                                        break Fail663;
                                      term = termFactory.makeAppl(Simplify._consLeq_2, new IStrategoTerm[]{i_478, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{k_478})});
                                      term = t_480.invoke(context, term);
                                      if(term == null)
                                        break Fail663;
                                      term = termFactory.makeAppl(Simplify._consOr_2, new IStrategoTerm[]{h_478, term});
                                      term = t_480.invoke(context, term);
                                      if(term == null)
                                        break Fail663;
                                      if(true)
                                        break Success449;
                                    }
                                    term = term254;
                                  }
                                  Success450:
                                  { 
                                    if(cons69 == Simplify._consOr_2)
                                    { 
                                      Fail664:
                                      { 
                                        IStrategoTerm o_478 = null;
                                        IStrategoTerm p_478 = null;
                                        IStrategoTerm q_478 = null;
                                        IStrategoTerm r_478 = null;
                                        IStrategoTerm arg417 = term.getSubterm(0);
                                        if(arg417.getTermType() != IStrategoTerm.APPL || Simplify._consOr_2 != ((IStrategoAppl)arg417).getConstructor())
                                          break Fail664;
                                        o_478 = arg417.getSubterm(0);
                                        IStrategoTerm arg418 = arg417.getSubterm(1);
                                        if(arg418.getTermType() != IStrategoTerm.APPL || Simplify._consLt_2 != ((IStrategoAppl)arg418).getConstructor())
                                          break Fail664;
                                        p_478 = arg418.getSubterm(0);
                                        IStrategoTerm arg419 = arg418.getSubterm(1);
                                        if(arg419.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg419).getConstructor())
                                          break Fail664;
                                        q_478 = arg419.getSubterm(0);
                                        IStrategoTerm arg420 = term.getSubterm(1);
                                        if(arg420.getTermType() != IStrategoTerm.APPL || Simplify._consLeq_2 != ((IStrategoAppl)arg420).getConstructor())
                                          break Fail664;
                                        if(arg420.getSubterm(0) != p_478 && !p_478.match(arg420.getSubterm(0)))
                                          break Fail664;
                                        IStrategoTerm arg421 = arg420.getSubterm(1);
                                        if(arg421.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg421).getConstructor())
                                          break Fail664;
                                        r_478 = arg421.getSubterm(0);
                                        term = termFactory.makeTuple(q_478, r_478);
                                        term = gt$S_0_0.instance.invoke(context, term);
                                        if(term == null)
                                          break Fail664;
                                        term = termFactory.makeAppl(Simplify._consLt_2, new IStrategoTerm[]{p_478, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{q_478})});
                                        term = t_480.invoke(context, term);
                                        if(term == null)
                                          break Fail664;
                                        term = termFactory.makeAppl(Simplify._consOr_2, new IStrategoTerm[]{o_478, term});
                                        term = t_480.invoke(context, term);
                                        if(term == null)
                                          break Fail664;
                                        if(true)
                                          break Success450;
                                      }
                                      term = term254;
                                    }
                                    Success451:
                                    { 
                                      if(cons69 == Simplify._consOr_2)
                                      { 
                                        Fail665:
                                        { 
                                          IStrategoTerm v_478 = null;
                                          IStrategoTerm w_478 = null;
                                          IStrategoTerm x_478 = null;
                                          IStrategoTerm y_478 = null;
                                          IStrategoTerm z_478 = null;
                                          IStrategoTerm arg422 = term.getSubterm(0);
                                          if(arg422.getTermType() != IStrategoTerm.APPL || Simplify._consOr_2 != ((IStrategoAppl)arg422).getConstructor())
                                            break Fail665;
                                          v_478 = arg422.getSubterm(0);
                                          IStrategoTerm arg423 = arg422.getSubterm(1);
                                          if(arg423.getTermType() != IStrategoTerm.APPL || Simplify._consLeq_2 != ((IStrategoAppl)arg423).getConstructor())
                                            break Fail665;
                                          w_478 = arg423.getSubterm(0);
                                          IStrategoTerm arg424 = arg423.getSubterm(1);
                                          if(arg424.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg424).getConstructor())
                                            break Fail665;
                                          x_478 = arg424.getSubterm(0);
                                          IStrategoTerm arg425 = term.getSubterm(1);
                                          if(arg425.getTermType() != IStrategoTerm.APPL || Simplify._consLeq_2 != ((IStrategoAppl)arg425).getConstructor())
                                            break Fail665;
                                          if(arg425.getSubterm(0) != w_478 && !w_478.match(arg425.getSubterm(0)))
                                            break Fail665;
                                          IStrategoTerm arg426 = arg425.getSubterm(1);
                                          if(arg426.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg426).getConstructor())
                                            break Fail665;
                                          y_478 = arg426.getSubterm(0);
                                          term = termFactory.makeTuple(x_478, y_478);
                                          term = maxstring_0_0.instance.invoke(context, term);
                                          if(term == null)
                                            break Fail665;
                                          z_478 = term;
                                          term = s_480.instance.invoke(context, z_478, t_480);
                                          if(term == null)
                                            break Fail665;
                                          term = termFactory.makeAppl(Simplify._consLeq_2, new IStrategoTerm[]{w_478, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{term})});
                                          term = t_480.invoke(context, term);
                                          if(term == null)
                                            break Fail665;
                                          term = termFactory.makeAppl(Simplify._consOr_2, new IStrategoTerm[]{v_478, term});
                                          term = t_480.invoke(context, term);
                                          if(term == null)
                                            break Fail665;
                                          if(true)
                                            break Success451;
                                        }
                                        term = term254;
                                      }
                                      Success452:
                                      { 
                                        if(cons69 == Simplify._consOr_2)
                                        { 
                                          Fail666:
                                          { 
                                            IStrategoTerm f_479 = null;
                                            IStrategoTerm g_479 = null;
                                            IStrategoTerm h_479 = null;
                                            IStrategoTerm arg427 = term.getSubterm(0);
                                            if(arg427.getTermType() != IStrategoTerm.APPL || Simplify._consOr_2 != ((IStrategoAppl)arg427).getConstructor())
                                              break Fail666;
                                            f_479 = arg427.getSubterm(0);
                                            IStrategoTerm arg428 = arg427.getSubterm(1);
                                            if(arg428.getTermType() != IStrategoTerm.APPL || Simplify._consEqu_2 != ((IStrategoAppl)arg428).getConstructor())
                                              break Fail666;
                                            g_479 = arg428.getSubterm(0);
                                            IStrategoTerm arg429 = arg428.getSubterm(1);
                                            if(arg429.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg429).getConstructor())
                                              break Fail666;
                                            h_479 = arg429.getSubterm(0);
                                            IStrategoTerm arg430 = term.getSubterm(1);
                                            if(arg430.getTermType() != IStrategoTerm.APPL || Simplify._consEqu_2 != ((IStrategoAppl)arg430).getConstructor())
                                              break Fail666;
                                            if(arg430.getSubterm(0) != g_479 && !g_479.match(arg430.getSubterm(0)))
                                              break Fail666;
                                            IStrategoTerm arg431 = arg430.getSubterm(1);
                                            if(arg431.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg431).getConstructor())
                                              break Fail666;
                                            if(arg431.getSubterm(0) != h_479 && !h_479.match(arg431.getSubterm(0)))
                                              break Fail666;
                                            term = termFactory.makeAppl(Simplify._consEqu_2, new IStrategoTerm[]{g_479, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{h_479})});
                                            term = t_480.invoke(context, term);
                                            if(term == null)
                                              break Fail666;
                                            term = termFactory.makeAppl(Simplify._consOr_2, new IStrategoTerm[]{f_479, term});
                                            term = t_480.invoke(context, term);
                                            if(term == null)
                                              break Fail666;
                                            if(true)
                                              break Success452;
                                          }
                                          term = term254;
                                        }
                                        Success453:
                                        { 
                                          if(cons69 == Simplify._consOr_2)
                                          { 
                                            Fail667:
                                            { 
                                              IStrategoTerm k_479 = null;
                                              IStrategoTerm l_479 = null;
                                              IStrategoTerm m_479 = null;
                                              IStrategoTerm n_479 = null;
                                              IStrategoTerm o_479 = null;
                                              IStrategoTerm arg432 = term.getSubterm(0);
                                              if(arg432.getTermType() != IStrategoTerm.APPL || Simplify._consOr_2 != ((IStrategoAppl)arg432).getConstructor())
                                                break Fail667;
                                              k_479 = arg432.getSubterm(0);
                                              IStrategoTerm arg433 = arg432.getSubterm(1);
                                              if(arg433.getTermType() != IStrategoTerm.APPL || Simplify._consGeq_2 != ((IStrategoAppl)arg433).getConstructor())
                                                break Fail667;
                                              l_479 = arg433.getSubterm(0);
                                              IStrategoTerm arg434 = arg433.getSubterm(1);
                                              if(arg434.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg434).getConstructor())
                                                break Fail667;
                                              m_479 = arg434.getSubterm(0);
                                              IStrategoTerm arg435 = term.getSubterm(1);
                                              if(arg435.getTermType() != IStrategoTerm.APPL || Simplify._consGeq_2 != ((IStrategoAppl)arg435).getConstructor())
                                                break Fail667;
                                              if(arg435.getSubterm(0) != l_479 && !l_479.match(arg435.getSubterm(0)))
                                                break Fail667;
                                              IStrategoTerm arg436 = arg435.getSubterm(1);
                                              if(arg436.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg436).getConstructor())
                                                break Fail667;
                                              n_479 = arg436.getSubterm(0);
                                              term = termFactory.makeTuple(m_479, n_479);
                                              term = minstring_0_0.instance.invoke(context, term);
                                              if(term == null)
                                                break Fail667;
                                              o_479 = term;
                                              term = s_480.instance.invoke(context, o_479, t_480);
                                              if(term == null)
                                                break Fail667;
                                              term = termFactory.makeAppl(Simplify._consGeq_2, new IStrategoTerm[]{l_479, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{term})});
                                              term = t_480.invoke(context, term);
                                              if(term == null)
                                                break Fail667;
                                              term = termFactory.makeAppl(Simplify._consOr_2, new IStrategoTerm[]{k_479, term});
                                              term = t_480.invoke(context, term);
                                              if(term == null)
                                                break Fail667;
                                              if(true)
                                                break Success453;
                                            }
                                            term = term254;
                                          }
                                          Success454:
                                          { 
                                            if(cons69 == Simplify._consOr_2)
                                            { 
                                              Fail668:
                                              { 
                                                IStrategoTerm u_479 = null;
                                                IStrategoTerm v_479 = null;
                                                IStrategoTerm w_479 = null;
                                                IStrategoTerm x_479 = null;
                                                IStrategoTerm arg437 = term.getSubterm(0);
                                                if(arg437.getTermType() != IStrategoTerm.APPL || Simplify._consOr_2 != ((IStrategoAppl)arg437).getConstructor())
                                                  break Fail668;
                                                u_479 = arg437.getSubterm(0);
                                                IStrategoTerm arg438 = arg437.getSubterm(1);
                                                if(arg438.getTermType() != IStrategoTerm.APPL || Simplify._consGeq_2 != ((IStrategoAppl)arg438).getConstructor())
                                                  break Fail668;
                                                v_479 = arg438.getSubterm(0);
                                                IStrategoTerm arg439 = arg438.getSubterm(1);
                                                if(arg439.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg439).getConstructor())
                                                  break Fail668;
                                                w_479 = arg439.getSubterm(0);
                                                IStrategoTerm arg440 = term.getSubterm(1);
                                                if(arg440.getTermType() != IStrategoTerm.APPL || Simplify._consGt_2 != ((IStrategoAppl)arg440).getConstructor())
                                                  break Fail668;
                                                if(arg440.getSubterm(0) != v_479 && !v_479.match(arg440.getSubterm(0)))
                                                  break Fail668;
                                                IStrategoTerm arg441 = arg440.getSubterm(1);
                                                if(arg441.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg441).getConstructor())
                                                  break Fail668;
                                                x_479 = arg441.getSubterm(0);
                                                term = termFactory.makeTuple(w_479, x_479);
                                                term = leq$S_0_0.instance.invoke(context, term);
                                                if(term == null)
                                                  break Fail668;
                                                term = termFactory.makeAppl(Simplify._consGeq_2, new IStrategoTerm[]{v_479, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{w_479})});
                                                term = t_480.invoke(context, term);
                                                if(term == null)
                                                  break Fail668;
                                                term = termFactory.makeAppl(Simplify._consOr_2, new IStrategoTerm[]{u_479, term});
                                                term = t_480.invoke(context, term);
                                                if(term == null)
                                                  break Fail668;
                                                if(true)
                                                  break Success454;
                                              }
                                              term = term254;
                                            }
                                            Success455:
                                            { 
                                              if(cons69 == Simplify._consOr_2)
                                              { 
                                                Fail669:
                                                { 
                                                  IStrategoTerm b_480 = null;
                                                  IStrategoTerm c_480 = null;
                                                  IStrategoTerm d_480 = null;
                                                  IStrategoTerm e_480 = null;
                                                  IStrategoTerm arg442 = term.getSubterm(0);
                                                  if(arg442.getTermType() != IStrategoTerm.APPL || Simplify._consOr_2 != ((IStrategoAppl)arg442).getConstructor())
                                                    break Fail669;
                                                  b_480 = arg442.getSubterm(0);
                                                  IStrategoTerm arg443 = arg442.getSubterm(1);
                                                  if(arg443.getTermType() != IStrategoTerm.APPL || Simplify._consGeq_2 != ((IStrategoAppl)arg443).getConstructor())
                                                    break Fail669;
                                                  c_480 = arg443.getSubterm(0);
                                                  IStrategoTerm arg444 = arg443.getSubterm(1);
                                                  if(arg444.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg444).getConstructor())
                                                    break Fail669;
                                                  d_480 = arg444.getSubterm(0);
                                                  IStrategoTerm arg445 = term.getSubterm(1);
                                                  if(arg445.getTermType() != IStrategoTerm.APPL || Simplify._consGt_2 != ((IStrategoAppl)arg445).getConstructor())
                                                    break Fail669;
                                                  if(arg445.getSubterm(0) != c_480 && !c_480.match(arg445.getSubterm(0)))
                                                    break Fail669;
                                                  IStrategoTerm arg446 = arg445.getSubterm(1);
                                                  if(arg446.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg446).getConstructor())
                                                    break Fail669;
                                                  e_480 = arg446.getSubterm(0);
                                                  term = termFactory.makeTuple(d_480, e_480);
                                                  term = gt$S_0_0.instance.invoke(context, term);
                                                  if(term == null)
                                                    break Fail669;
                                                  term = termFactory.makeAppl(Simplify._consGt_2, new IStrategoTerm[]{c_480, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{e_480})});
                                                  term = t_480.invoke(context, term);
                                                  if(term == null)
                                                    break Fail669;
                                                  term = termFactory.makeAppl(Simplify._consOr_2, new IStrategoTerm[]{b_480, term});
                                                  term = t_480.invoke(context, term);
                                                  if(term == null)
                                                    break Fail669;
                                                  if(true)
                                                    break Success455;
                                                }
                                                term = term254;
                                              }
                                              if(cons69 == Simplify._consOr_2)
                                              { 
                                                IStrategoTerm i_480 = null;
                                                IStrategoTerm j_480 = null;
                                                IStrategoTerm k_480 = null;
                                                IStrategoTerm l_480 = null;
                                                IStrategoTerm m_480 = null;
                                                IStrategoTerm arg447 = term.getSubterm(0);
                                                if(arg447.getTermType() != IStrategoTerm.APPL || Simplify._consOr_2 != ((IStrategoAppl)arg447).getConstructor())
                                                  break Fail650;
                                                i_480 = arg447.getSubterm(0);
                                                IStrategoTerm arg448 = arg447.getSubterm(1);
                                                if(arg448.getTermType() != IStrategoTerm.APPL || Simplify._consGt_2 != ((IStrategoAppl)arg448).getConstructor())
                                                  break Fail650;
                                                j_480 = arg448.getSubterm(0);
                                                IStrategoTerm arg449 = arg448.getSubterm(1);
                                                if(arg449.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg449).getConstructor())
                                                  break Fail650;
                                                k_480 = arg449.getSubterm(0);
                                                IStrategoTerm arg450 = term.getSubterm(1);
                                                if(arg450.getTermType() != IStrategoTerm.APPL || Simplify._consGt_2 != ((IStrategoAppl)arg450).getConstructor())
                                                  break Fail650;
                                                if(arg450.getSubterm(0) != j_480 && !j_480.match(arg450.getSubterm(0)))
                                                  break Fail650;
                                                IStrategoTerm arg451 = arg450.getSubterm(1);
                                                if(arg451.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg451).getConstructor())
                                                  break Fail650;
                                                l_480 = arg451.getSubterm(0);
                                                term = termFactory.makeTuple(k_480, l_480);
                                                term = minstring_0_0.instance.invoke(context, term);
                                                if(term == null)
                                                  break Fail650;
                                                m_480 = term;
                                                term = s_480.instance.invoke(context, m_480, t_480);
                                                if(term == null)
                                                  break Fail650;
                                                term = termFactory.makeAppl(Simplify._consGt_2, new IStrategoTerm[]{j_480, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{term})});
                                                term = t_480.invoke(context, term);
                                                if(term == null)
                                                  break Fail650;
                                                term = termFactory.makeAppl(Simplify._consOr_2, new IStrategoTerm[]{i_480, term});
                                                term = t_480.invoke(context, term);
                                                if(term == null)
                                                  break Fail650;
                                              }
                                              else
                                              { 
                                                break Fail650;
                                              }
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class canonical_0_0_fragment_1 extends Strategy 
  { 
    Strategy t_480;

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      ITermFactory termFactory = context.getFactory();
      Fail670:
      { 
        IStrategoTerm term182 = term;
        IStrategoConstructor cons70 = term.getTermType() == IStrategoTerm.APPL ? ((IStrategoAppl)term).getConstructor() : null;
        Success456:
        { 
          if(cons70 == Simplify._consAdd_2)
          { 
            Fail671:
            { 
              IStrategoTerm m_461 = null;
              IStrategoTerm q_461 = null;
              IStrategoTerm v_461 = null;
              m_461 = term.getSubterm(0);
              q_461 = term.getSubterm(1);
              term = q_461;
              IStrategoTerm term183 = term;
              Success457:
              { 
                Fail672:
                { 
                  if(term.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)term).getConstructor())
                    break Fail672;
                  { 
                    if(true)
                      break Fail671;
                    if(true)
                      break Success457;
                  }
                }
                term = term183;
              }
              term = q_461;
              IStrategoTerm term184 = term;
              Success458:
              { 
                Fail673:
                { 
                  if(term.getTermType() != IStrategoTerm.APPL || Simplify._consMul_2 != ((IStrategoAppl)term).getConstructor())
                    break Fail673;
                  IStrategoTerm arg215 = term.getSubterm(1);
                  if(arg215.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg215).getConstructor())
                    break Fail673;
                  { 
                    if(true)
                      break Fail671;
                    if(true)
                      break Success458;
                  }
                }
                term = term184;
              }
              term = q_461;
              IStrategoTerm term185 = term;
              Success459:
              { 
                Fail674:
                { 
                  if(term.getTermType() != IStrategoTerm.APPL || Simplify._consAdd_2 != ((IStrategoAppl)term).getConstructor())
                    break Fail674;
                  { 
                    if(true)
                      break Fail671;
                    if(true)
                      break Success459;
                  }
                }
                term = term185;
              }
              v_461 = term;
              term = get_option_0_1.instance.invoke(context, v_461, Simplify.constMerge_complex_multiply0);
              if(term == null)
                break Fail671;
              term = termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{q_461, Simplify.constInt0});
              term = t_480.invoke(context, term);
              if(term == null)
                break Fail671;
              term = termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{m_461, term});
              term = t_480.invoke(context, term);
              if(term == null)
                break Fail671;
              if(true)
                break Success456;
            }
            term = term182;
          }
          Success460:
          { 
            if(cons70 == Simplify._consLt_2)
            { 
              Fail675:
              { 
                IStrategoTerm y_461 = null;
                IStrategoTerm z_461 = null;
                IStrategoTerm arg216 = term.getSubterm(0);
                if(arg216.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg216).getConstructor())
                  break Fail675;
                z_461 = arg216.getSubterm(0);
                y_461 = term.getSubterm(1);
                term = termFactory.makeAppl(Simplify._consGt_2, new IStrategoTerm[]{y_461, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{z_461})});
                term = t_480.invoke(context, term);
                if(term == null)
                  break Fail675;
                if(true)
                  break Success460;
              }
              term = term182;
            }
            Success461:
            { 
              if(cons70 == Simplify._consLeq_2)
              { 
                Fail676:
                { 
                  IStrategoTerm a_462 = null;
                  IStrategoTerm b_462 = null;
                  IStrategoTerm arg217 = term.getSubterm(0);
                  if(arg217.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg217).getConstructor())
                    break Fail676;
                  b_462 = arg217.getSubterm(0);
                  a_462 = term.getSubterm(1);
                  term = termFactory.makeAppl(Simplify._consGeq_2, new IStrategoTerm[]{a_462, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{b_462})});
                  term = t_480.invoke(context, term);
                  if(term == null)
                    break Fail676;
                  if(true)
                    break Success461;
                }
                term = term182;
              }
              Success462:
              { 
                if(cons70 == Simplify._consEqu_2)
                { 
                  Fail677:
                  { 
                    IStrategoTerm c_462 = null;
                    IStrategoTerm d_462 = null;
                    IStrategoTerm arg218 = term.getSubterm(0);
                    if(arg218.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg218).getConstructor())
                      break Fail677;
                    d_462 = arg218.getSubterm(0);
                    c_462 = term.getSubterm(1);
                    term = termFactory.makeAppl(Simplify._consEqu_2, new IStrategoTerm[]{c_462, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{d_462})});
                    term = t_480.invoke(context, term);
                    if(term == null)
                      break Fail677;
                    if(true)
                      break Success462;
                  }
                  term = term182;
                }
                Success463:
                { 
                  if(cons70 == Simplify._consGt_2)
                  { 
                    Fail678:
                    { 
                      IStrategoTerm e_462 = null;
                      IStrategoTerm f_462 = null;
                      IStrategoTerm arg219 = term.getSubterm(0);
                      if(arg219.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg219).getConstructor())
                        break Fail678;
                      f_462 = arg219.getSubterm(0);
                      e_462 = term.getSubterm(1);
                      term = termFactory.makeAppl(Simplify._consLt_2, new IStrategoTerm[]{e_462, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{f_462})});
                      term = t_480.invoke(context, term);
                      if(term == null)
                        break Fail678;
                      if(true)
                        break Success463;
                    }
                    term = term182;
                  }
                  Success464:
                  { 
                    if(cons70 == Simplify._consGeq_2)
                    { 
                      Fail679:
                      { 
                        IStrategoTerm g_462 = null;
                        IStrategoTerm h_462 = null;
                        IStrategoTerm arg220 = term.getSubterm(0);
                        if(arg220.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg220).getConstructor())
                          break Fail679;
                        h_462 = arg220.getSubterm(0);
                        g_462 = term.getSubterm(1);
                        term = termFactory.makeAppl(Simplify._consLeq_2, new IStrategoTerm[]{g_462, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{h_462})});
                        term = t_480.invoke(context, term);
                        if(term == null)
                          break Fail679;
                        if(true)
                          break Success464;
                      }
                      term = term182;
                    }
                    Success465:
                    { 
                      if(cons70 == Simplify._consNeq_2)
                      { 
                        Fail680:
                        { 
                          IStrategoTerm i_462 = null;
                          IStrategoTerm j_462 = null;
                          IStrategoTerm arg221 = term.getSubterm(0);
                          if(arg221.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg221).getConstructor())
                            break Fail680;
                          j_462 = arg221.getSubterm(0);
                          i_462 = term.getSubterm(1);
                          term = termFactory.makeAppl(Simplify._consNeq_2, new IStrategoTerm[]{i_462, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{j_462})});
                          term = t_480.invoke(context, term);
                          if(term == null)
                            break Fail680;
                          if(true)
                            break Success465;
                        }
                        term = term182;
                      }
                      Success466:
                      { 
                        if(cons70 == Simplify._consLt_2)
                        { 
                          Fail681:
                          { 
                            IStrategoTerm k_462 = null;
                            IStrategoTerm l_462 = null;
                            IStrategoTerm m_462 = null;
                            IStrategoTerm arg222 = term.getSubterm(0);
                            if(arg222.getTermType() != IStrategoTerm.APPL || Simplify._consAdd_2 != ((IStrategoAppl)arg222).getConstructor())
                              break Fail681;
                            k_462 = arg222.getSubterm(0);
                            IStrategoTerm arg223 = arg222.getSubterm(1);
                            if(arg223.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg223).getConstructor())
                              break Fail681;
                            m_462 = arg223.getSubterm(0);
                            l_462 = term.getSubterm(1);
                            term = termFactory.makeAppl(Simplify._consNeg_1, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{m_462})});
                            term = t_480.invoke(context, term);
                            if(term == null)
                              break Fail681;
                            term = termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{l_462, term});
                            term = t_480.invoke(context, term);
                            if(term == null)
                              break Fail681;
                            term = termFactory.makeAppl(Simplify._consLt_2, new IStrategoTerm[]{k_462, term});
                            term = t_480.invoke(context, term);
                            if(term == null)
                              break Fail681;
                            if(true)
                              break Success466;
                          }
                          term = term182;
                        }
                        Success467:
                        { 
                          if(cons70 == Simplify._consLeq_2)
                          { 
                            Fail682:
                            { 
                              IStrategoTerm r_462 = null;
                              IStrategoTerm s_462 = null;
                              IStrategoTerm t_462 = null;
                              IStrategoTerm arg224 = term.getSubterm(0);
                              if(arg224.getTermType() != IStrategoTerm.APPL || Simplify._consAdd_2 != ((IStrategoAppl)arg224).getConstructor())
                                break Fail682;
                              r_462 = arg224.getSubterm(0);
                              IStrategoTerm arg225 = arg224.getSubterm(1);
                              if(arg225.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg225).getConstructor())
                                break Fail682;
                              t_462 = arg225.getSubterm(0);
                              s_462 = term.getSubterm(1);
                              term = termFactory.makeAppl(Simplify._consNeg_1, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{t_462})});
                              term = t_480.invoke(context, term);
                              if(term == null)
                                break Fail682;
                              term = termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{s_462, term});
                              term = t_480.invoke(context, term);
                              if(term == null)
                                break Fail682;
                              term = termFactory.makeAppl(Simplify._consLeq_2, new IStrategoTerm[]{r_462, term});
                              term = t_480.invoke(context, term);
                              if(term == null)
                                break Fail682;
                              if(true)
                                break Success467;
                            }
                            term = term182;
                          }
                          Success468:
                          { 
                            if(cons70 == Simplify._consEqu_2)
                            { 
                              Fail683:
                              { 
                                IStrategoTerm y_462 = null;
                                IStrategoTerm z_462 = null;
                                IStrategoTerm a_463 = null;
                                IStrategoTerm arg226 = term.getSubterm(0);
                                if(arg226.getTermType() != IStrategoTerm.APPL || Simplify._consAdd_2 != ((IStrategoAppl)arg226).getConstructor())
                                  break Fail683;
                                y_462 = arg226.getSubterm(0);
                                IStrategoTerm arg227 = arg226.getSubterm(1);
                                if(arg227.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg227).getConstructor())
                                  break Fail683;
                                a_463 = arg227.getSubterm(0);
                                z_462 = term.getSubterm(1);
                                term = termFactory.makeAppl(Simplify._consNeg_1, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{a_463})});
                                term = t_480.invoke(context, term);
                                if(term == null)
                                  break Fail683;
                                term = termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{z_462, term});
                                term = t_480.invoke(context, term);
                                if(term == null)
                                  break Fail683;
                                term = termFactory.makeAppl(Simplify._consEqu_2, new IStrategoTerm[]{y_462, term});
                                term = t_480.invoke(context, term);
                                if(term == null)
                                  break Fail683;
                                if(true)
                                  break Success468;
                              }
                              term = term182;
                            }
                            Success469:
                            { 
                              if(cons70 == Simplify._consGt_2)
                              { 
                                Fail684:
                                { 
                                  IStrategoTerm f_463 = null;
                                  IStrategoTerm g_463 = null;
                                  IStrategoTerm h_463 = null;
                                  IStrategoTerm arg228 = term.getSubterm(0);
                                  if(arg228.getTermType() != IStrategoTerm.APPL || Simplify._consAdd_2 != ((IStrategoAppl)arg228).getConstructor())
                                    break Fail684;
                                  f_463 = arg228.getSubterm(0);
                                  IStrategoTerm arg229 = arg228.getSubterm(1);
                                  if(arg229.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg229).getConstructor())
                                    break Fail684;
                                  h_463 = arg229.getSubterm(0);
                                  g_463 = term.getSubterm(1);
                                  term = termFactory.makeAppl(Simplify._consNeg_1, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{h_463})});
                                  term = t_480.invoke(context, term);
                                  if(term == null)
                                    break Fail684;
                                  term = termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{g_463, term});
                                  term = t_480.invoke(context, term);
                                  if(term == null)
                                    break Fail684;
                                  term = termFactory.makeAppl(Simplify._consGt_2, new IStrategoTerm[]{f_463, term});
                                  term = t_480.invoke(context, term);
                                  if(term == null)
                                    break Fail684;
                                  if(true)
                                    break Success469;
                                }
                                term = term182;
                              }
                              Success470:
                              { 
                                if(cons70 == Simplify._consGeq_2)
                                { 
                                  Fail685:
                                  { 
                                    IStrategoTerm m_463 = null;
                                    IStrategoTerm n_463 = null;
                                    IStrategoTerm o_463 = null;
                                    IStrategoTerm arg230 = term.getSubterm(0);
                                    if(arg230.getTermType() != IStrategoTerm.APPL || Simplify._consAdd_2 != ((IStrategoAppl)arg230).getConstructor())
                                      break Fail685;
                                    m_463 = arg230.getSubterm(0);
                                    IStrategoTerm arg231 = arg230.getSubterm(1);
                                    if(arg231.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg231).getConstructor())
                                      break Fail685;
                                    o_463 = arg231.getSubterm(0);
                                    n_463 = term.getSubterm(1);
                                    term = termFactory.makeAppl(Simplify._consNeg_1, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{o_463})});
                                    term = t_480.invoke(context, term);
                                    if(term == null)
                                      break Fail685;
                                    term = termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{n_463, term});
                                    term = t_480.invoke(context, term);
                                    if(term == null)
                                      break Fail685;
                                    term = termFactory.makeAppl(Simplify._consGeq_2, new IStrategoTerm[]{m_463, term});
                                    term = t_480.invoke(context, term);
                                    if(term == null)
                                      break Fail685;
                                    if(true)
                                      break Success470;
                                  }
                                  term = term182;
                                }
                                Success471:
                                { 
                                  if(cons70 == Simplify._consNeq_2)
                                  { 
                                    Fail686:
                                    { 
                                      IStrategoTerm t_463 = null;
                                      IStrategoTerm u_463 = null;
                                      IStrategoTerm v_463 = null;
                                      IStrategoTerm arg232 = term.getSubterm(0);
                                      if(arg232.getTermType() != IStrategoTerm.APPL || Simplify._consAdd_2 != ((IStrategoAppl)arg232).getConstructor())
                                        break Fail686;
                                      t_463 = arg232.getSubterm(0);
                                      IStrategoTerm arg233 = arg232.getSubterm(1);
                                      if(arg233.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg233).getConstructor())
                                        break Fail686;
                                      v_463 = arg233.getSubterm(0);
                                      u_463 = term.getSubterm(1);
                                      term = termFactory.makeAppl(Simplify._consNeg_1, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{v_463})});
                                      term = t_480.invoke(context, term);
                                      if(term == null)
                                        break Fail686;
                                      term = termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{u_463, term});
                                      term = t_480.invoke(context, term);
                                      if(term == null)
                                        break Fail686;
                                      term = termFactory.makeAppl(Simplify._consNeq_2, new IStrategoTerm[]{t_463, term});
                                      term = t_480.invoke(context, term);
                                      if(term == null)
                                        break Fail686;
                                      if(true)
                                        break Success471;
                                    }
                                    term = term182;
                                  }
                                  Success472:
                                  { 
                                    if(cons70 == Simplify._consLt_2)
                                    { 
                                      Fail687:
                                      { 
                                        IStrategoTerm a_464 = null;
                                        IStrategoTerm b_464 = null;
                                        IStrategoTerm c_464 = null;
                                        a_464 = term.getSubterm(0);
                                        IStrategoTerm arg234 = term.getSubterm(1);
                                        if(arg234.getTermType() != IStrategoTerm.APPL || Simplify._consAdd_2 != ((IStrategoAppl)arg234).getConstructor())
                                          break Fail687;
                                        b_464 = arg234.getSubterm(0);
                                        c_464 = arg234.getSubterm(1);
                                        term = termFactory.makeAppl(Simplify._consNeg_1, new IStrategoTerm[]{b_464});
                                        term = t_480.invoke(context, term);
                                        if(term == null)
                                          break Fail687;
                                        term = termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{a_464, term});
                                        term = t_480.invoke(context, term);
                                        if(term == null)
                                          break Fail687;
                                        term = termFactory.makeAppl(Simplify._consLt_2, new IStrategoTerm[]{term, c_464});
                                        term = t_480.invoke(context, term);
                                        if(term == null)
                                          break Fail687;
                                        if(true)
                                          break Success472;
                                      }
                                      term = term182;
                                    }
                                    Success473:
                                    { 
                                      if(cons70 == Simplify._consLeq_2)
                                      { 
                                        Fail688:
                                        { 
                                          IStrategoTerm h_464 = null;
                                          IStrategoTerm i_464 = null;
                                          IStrategoTerm j_464 = null;
                                          h_464 = term.getSubterm(0);
                                          IStrategoTerm arg235 = term.getSubterm(1);
                                          if(arg235.getTermType() != IStrategoTerm.APPL || Simplify._consAdd_2 != ((IStrategoAppl)arg235).getConstructor())
                                            break Fail688;
                                          i_464 = arg235.getSubterm(0);
                                          j_464 = arg235.getSubterm(1);
                                          term = termFactory.makeAppl(Simplify._consNeg_1, new IStrategoTerm[]{i_464});
                                          term = t_480.invoke(context, term);
                                          if(term == null)
                                            break Fail688;
                                          term = termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{h_464, term});
                                          term = t_480.invoke(context, term);
                                          if(term == null)
                                            break Fail688;
                                          term = termFactory.makeAppl(Simplify._consLeq_2, new IStrategoTerm[]{term, j_464});
                                          term = t_480.invoke(context, term);
                                          if(term == null)
                                            break Fail688;
                                          if(true)
                                            break Success473;
                                        }
                                        term = term182;
                                      }
                                      Success474:
                                      { 
                                        if(cons70 == Simplify._consEqu_2)
                                        { 
                                          Fail689:
                                          { 
                                            IStrategoTerm o_464 = null;
                                            IStrategoTerm p_464 = null;
                                            IStrategoTerm q_464 = null;
                                            o_464 = term.getSubterm(0);
                                            IStrategoTerm arg236 = term.getSubterm(1);
                                            if(arg236.getTermType() != IStrategoTerm.APPL || Simplify._consAdd_2 != ((IStrategoAppl)arg236).getConstructor())
                                              break Fail689;
                                            p_464 = arg236.getSubterm(0);
                                            q_464 = arg236.getSubterm(1);
                                            term = termFactory.makeAppl(Simplify._consNeg_1, new IStrategoTerm[]{p_464});
                                            term = t_480.invoke(context, term);
                                            if(term == null)
                                              break Fail689;
                                            term = termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{o_464, term});
                                            term = t_480.invoke(context, term);
                                            if(term == null)
                                              break Fail689;
                                            term = termFactory.makeAppl(Simplify._consEqu_2, new IStrategoTerm[]{term, q_464});
                                            term = t_480.invoke(context, term);
                                            if(term == null)
                                              break Fail689;
                                            if(true)
                                              break Success474;
                                          }
                                          term = term182;
                                        }
                                        Success475:
                                        { 
                                          if(cons70 == Simplify._consGt_2)
                                          { 
                                            Fail690:
                                            { 
                                              IStrategoTerm v_464 = null;
                                              IStrategoTerm w_464 = null;
                                              IStrategoTerm x_464 = null;
                                              v_464 = term.getSubterm(0);
                                              IStrategoTerm arg237 = term.getSubterm(1);
                                              if(arg237.getTermType() != IStrategoTerm.APPL || Simplify._consAdd_2 != ((IStrategoAppl)arg237).getConstructor())
                                                break Fail690;
                                              w_464 = arg237.getSubterm(0);
                                              x_464 = arg237.getSubterm(1);
                                              term = termFactory.makeAppl(Simplify._consNeg_1, new IStrategoTerm[]{w_464});
                                              term = t_480.invoke(context, term);
                                              if(term == null)
                                                break Fail690;
                                              term = termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{v_464, term});
                                              term = t_480.invoke(context, term);
                                              if(term == null)
                                                break Fail690;
                                              term = termFactory.makeAppl(Simplify._consGt_2, new IStrategoTerm[]{term, x_464});
                                              term = t_480.invoke(context, term);
                                              if(term == null)
                                                break Fail690;
                                              if(true)
                                                break Success475;
                                            }
                                            term = term182;
                                          }
                                          Success476:
                                          { 
                                            if(cons70 == Simplify._consGeq_2)
                                            { 
                                              Fail691:
                                              { 
                                                IStrategoTerm c_465 = null;
                                                IStrategoTerm d_465 = null;
                                                IStrategoTerm e_465 = null;
                                                c_465 = term.getSubterm(0);
                                                IStrategoTerm arg238 = term.getSubterm(1);
                                                if(arg238.getTermType() != IStrategoTerm.APPL || Simplify._consAdd_2 != ((IStrategoAppl)arg238).getConstructor())
                                                  break Fail691;
                                                d_465 = arg238.getSubterm(0);
                                                e_465 = arg238.getSubterm(1);
                                                term = termFactory.makeAppl(Simplify._consNeg_1, new IStrategoTerm[]{d_465});
                                                term = t_480.invoke(context, term);
                                                if(term == null)
                                                  break Fail691;
                                                term = termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{c_465, term});
                                                term = t_480.invoke(context, term);
                                                if(term == null)
                                                  break Fail691;
                                                term = termFactory.makeAppl(Simplify._consGeq_2, new IStrategoTerm[]{term, e_465});
                                                term = t_480.invoke(context, term);
                                                if(term == null)
                                                  break Fail691;
                                                if(true)
                                                  break Success476;
                                              }
                                              term = term182;
                                            }
                                            Success477:
                                            { 
                                              if(cons70 == Simplify._consNeq_2)
                                              { 
                                                Fail692:
                                                { 
                                                  IStrategoTerm j_465 = null;
                                                  IStrategoTerm k_465 = null;
                                                  IStrategoTerm l_465 = null;
                                                  j_465 = term.getSubterm(0);
                                                  IStrategoTerm arg239 = term.getSubterm(1);
                                                  if(arg239.getTermType() != IStrategoTerm.APPL || Simplify._consAdd_2 != ((IStrategoAppl)arg239).getConstructor())
                                                    break Fail692;
                                                  k_465 = arg239.getSubterm(0);
                                                  l_465 = arg239.getSubterm(1);
                                                  term = termFactory.makeAppl(Simplify._consNeg_1, new IStrategoTerm[]{k_465});
                                                  term = t_480.invoke(context, term);
                                                  if(term == null)
                                                    break Fail692;
                                                  term = termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{j_465, term});
                                                  term = t_480.invoke(context, term);
                                                  if(term == null)
                                                    break Fail692;
                                                  term = termFactory.makeAppl(Simplify._consNeq_2, new IStrategoTerm[]{term, l_465});
                                                  term = t_480.invoke(context, term);
                                                  if(term == null)
                                                    break Fail692;
                                                  if(true)
                                                    break Success477;
                                                }
                                                term = term182;
                                              }
                                              Success478:
                                              { 
                                                if(cons70 == Simplify._consLt_2)
                                                { 
                                                  Fail693:
                                                  { 
                                                    IStrategoTerm q_465 = null;
                                                    IStrategoTerm r_465 = null;
                                                    q_465 = term.getSubterm(0);
                                                    r_465 = term.getSubterm(1);
                                                    term = r_465;
                                                    IStrategoTerm term205 = term;
                                                    Success479:
                                                    { 
                                                      Fail694:
                                                      { 
                                                        if(term.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)term).getConstructor())
                                                          break Fail694;
                                                        { 
                                                          if(true)
                                                            break Fail693;
                                                          if(true)
                                                            break Success479;
                                                        }
                                                      }
                                                      term = term205;
                                                    }
                                                    term = termFactory.makeAppl(Simplify._consNeg_1, new IStrategoTerm[]{r_465});
                                                    term = t_480.invoke(context, term);
                                                    if(term == null)
                                                      break Fail693;
                                                    term = termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{q_465, term});
                                                    term = t_480.invoke(context, term);
                                                    if(term == null)
                                                      break Fail693;
                                                    term = termFactory.makeAppl(Simplify._consLt_2, new IStrategoTerm[]{term, Simplify.constInt3});
                                                    term = t_480.invoke(context, term);
                                                    if(term == null)
                                                      break Fail693;
                                                    if(true)
                                                      break Success478;
                                                  }
                                                  term = term182;
                                                }
                                                Success480:
                                                { 
                                                  if(cons70 == Simplify._consLeq_2)
                                                  { 
                                                    Fail695:
                                                    { 
                                                      IStrategoTerm y_465 = null;
                                                      IStrategoTerm z_465 = null;
                                                      y_465 = term.getSubterm(0);
                                                      z_465 = term.getSubterm(1);
                                                      term = z_465;
                                                      IStrategoTerm term207 = term;
                                                      Success481:
                                                      { 
                                                        Fail696:
                                                        { 
                                                          if(term.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)term).getConstructor())
                                                            break Fail696;
                                                          { 
                                                            if(true)
                                                              break Fail695;
                                                            if(true)
                                                              break Success481;
                                                          }
                                                        }
                                                        term = term207;
                                                      }
                                                      term = termFactory.makeAppl(Simplify._consNeg_1, new IStrategoTerm[]{z_465});
                                                      term = t_480.invoke(context, term);
                                                      if(term == null)
                                                        break Fail695;
                                                      term = termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{y_465, term});
                                                      term = t_480.invoke(context, term);
                                                      if(term == null)
                                                        break Fail695;
                                                      term = termFactory.makeAppl(Simplify._consLeq_2, new IStrategoTerm[]{term, Simplify.constInt3});
                                                      term = t_480.invoke(context, term);
                                                      if(term == null)
                                                        break Fail695;
                                                      if(true)
                                                        break Success480;
                                                    }
                                                    term = term182;
                                                  }
                                                  Success482:
                                                  { 
                                                    if(cons70 == Simplify._consEqu_2)
                                                    { 
                                                      Fail697:
                                                      { 
                                                        IStrategoTerm g_466 = null;
                                                        IStrategoTerm h_466 = null;
                                                        g_466 = term.getSubterm(0);
                                                        h_466 = term.getSubterm(1);
                                                        term = h_466;
                                                        IStrategoTerm term209 = term;
                                                        Success483:
                                                        { 
                                                          Fail698:
                                                          { 
                                                            if(term.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)term).getConstructor())
                                                              break Fail698;
                                                            { 
                                                              if(true)
                                                                break Fail697;
                                                              if(true)
                                                                break Success483;
                                                            }
                                                          }
                                                          term = term209;
                                                        }
                                                        term = termFactory.makeAppl(Simplify._consNeg_1, new IStrategoTerm[]{h_466});
                                                        term = t_480.invoke(context, term);
                                                        if(term == null)
                                                          break Fail697;
                                                        term = termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{g_466, term});
                                                        term = t_480.invoke(context, term);
                                                        if(term == null)
                                                          break Fail697;
                                                        term = termFactory.makeAppl(Simplify._consEqu_2, new IStrategoTerm[]{term, Simplify.constInt3});
                                                        term = t_480.invoke(context, term);
                                                        if(term == null)
                                                          break Fail697;
                                                        if(true)
                                                          break Success482;
                                                      }
                                                      term = term182;
                                                    }
                                                    Success484:
                                                    { 
                                                      if(cons70 == Simplify._consGt_2)
                                                      { 
                                                        Fail699:
                                                        { 
                                                          IStrategoTerm o_466 = null;
                                                          IStrategoTerm p_466 = null;
                                                          o_466 = term.getSubterm(0);
                                                          p_466 = term.getSubterm(1);
                                                          term = p_466;
                                                          IStrategoTerm term211 = term;
                                                          Success485:
                                                          { 
                                                            Fail700:
                                                            { 
                                                              if(term.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)term).getConstructor())
                                                                break Fail700;
                                                              { 
                                                                if(true)
                                                                  break Fail699;
                                                                if(true)
                                                                  break Success485;
                                                              }
                                                            }
                                                            term = term211;
                                                          }
                                                          term = termFactory.makeAppl(Simplify._consNeg_1, new IStrategoTerm[]{p_466});
                                                          term = t_480.invoke(context, term);
                                                          if(term == null)
                                                            break Fail699;
                                                          term = termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{o_466, term});
                                                          term = t_480.invoke(context, term);
                                                          if(term == null)
                                                            break Fail699;
                                                          term = termFactory.makeAppl(Simplify._consGt_2, new IStrategoTerm[]{term, Simplify.constInt3});
                                                          term = t_480.invoke(context, term);
                                                          if(term == null)
                                                            break Fail699;
                                                          if(true)
                                                            break Success484;
                                                        }
                                                        term = term182;
                                                      }
                                                      Success486:
                                                      { 
                                                        if(cons70 == Simplify._consGeq_2)
                                                        { 
                                                          Fail701:
                                                          { 
                                                            IStrategoTerm w_466 = null;
                                                            IStrategoTerm x_466 = null;
                                                            w_466 = term.getSubterm(0);
                                                            x_466 = term.getSubterm(1);
                                                            term = x_466;
                                                            IStrategoTerm term213 = term;
                                                            Success487:
                                                            { 
                                                              Fail702:
                                                              { 
                                                                if(term.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)term).getConstructor())
                                                                  break Fail702;
                                                                { 
                                                                  if(true)
                                                                    break Fail701;
                                                                  if(true)
                                                                    break Success487;
                                                                }
                                                              }
                                                              term = term213;
                                                            }
                                                            term = termFactory.makeAppl(Simplify._consNeg_1, new IStrategoTerm[]{x_466});
                                                            term = t_480.invoke(context, term);
                                                            if(term == null)
                                                              break Fail701;
                                                            term = termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{w_466, term});
                                                            term = t_480.invoke(context, term);
                                                            if(term == null)
                                                              break Fail701;
                                                            term = termFactory.makeAppl(Simplify._consGeq_2, new IStrategoTerm[]{term, Simplify.constInt3});
                                                            term = t_480.invoke(context, term);
                                                            if(term == null)
                                                              break Fail701;
                                                            if(true)
                                                              break Success486;
                                                          }
                                                          term = term182;
                                                        }
                                                        if(cons70 == Simplify._consNeq_2)
                                                        { 
                                                          IStrategoTerm e_467 = null;
                                                          IStrategoTerm f_467 = null;
                                                          e_467 = term.getSubterm(0);
                                                          f_467 = term.getSubterm(1);
                                                          term = f_467;
                                                          IStrategoTerm term214 = term;
                                                          Success488:
                                                          { 
                                                            Fail703:
                                                            { 
                                                              if(term.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)term).getConstructor())
                                                                break Fail703;
                                                              { 
                                                                if(true)
                                                                  break Fail670;
                                                                if(true)
                                                                  break Success488;
                                                              }
                                                            }
                                                            term = term214;
                                                          }
                                                          term = termFactory.makeAppl(Simplify._consNeg_1, new IStrategoTerm[]{f_467});
                                                          term = t_480.invoke(context, term);
                                                          if(term == null)
                                                            break Fail670;
                                                          term = termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{e_467, term});
                                                          term = t_480.invoke(context, term);
                                                          if(term == null)
                                                            break Fail670;
                                                          term = termFactory.makeAppl(Simplify._consNeq_2, new IStrategoTerm[]{term, Simplify.constInt3});
                                                          term = t_480.invoke(context, term);
                                                          if(term == null)
                                                            break Fail670;
                                                        }
                                                        else
                                                        { 
                                                          break Fail670;
                                                        }
                                                      }
                                                    }
                                                  }
                                                }
                                              }
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class canonical_0_0_fragment_0 extends Strategy 
  { 
    Strategy t_480;

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      ITermFactory termFactory = context.getFactory();
      Fail704:
      { 
        IStrategoTerm term126 = term;
        IStrategoConstructor cons80 = term.getTermType() == IStrategoTerm.APPL ? ((IStrategoAppl)term).getConstructor() : null;
        Success489:
        { 
          if(cons80 == Simplify._consAdd_2)
          { 
            Fail705:
            { 
              IStrategoTerm g_454 = null;
              IStrategoTerm h_454 = null;
              IStrategoTerm i_454 = null;
              IStrategoTerm j_454 = null;
              IStrategoTerm arg121 = term.getSubterm(0);
              if(arg121.getTermType() != IStrategoTerm.APPL || Simplify._consAdd_2 != ((IStrategoAppl)arg121).getConstructor())
                break Fail705;
              g_454 = arg121.getSubterm(0);
              IStrategoTerm arg122 = arg121.getSubterm(1);
              if(arg122.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg122).getConstructor())
                break Fail705;
              h_454 = arg122.getSubterm(0);
              IStrategoTerm arg123 = term.getSubterm(1);
              if(arg123.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg123).getConstructor())
                break Fail705;
              i_454 = arg123.getSubterm(0);
              term = termFactory.makeTuple(h_454, i_454);
              term = add$S_0_0.instance.invoke(context, term);
              if(term == null)
                break Fail705;
              j_454 = term;
              term = s_480.instance.invoke(context, j_454, t_480);
              if(term == null)
                break Fail705;
              term = termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{g_454, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{term})});
              term = t_480.invoke(context, term);
              if(term == null)
                break Fail705;
              if(true)
                break Success489;
            }
            term = term126;
          }
          Success490:
          { 
            if(cons80 == Simplify._consMul_2)
            { 
              Fail706:
              { 
                IStrategoTerm n_454 = null;
                IStrategoTerm o_454 = null;
                IStrategoTerm p_454 = null;
                IStrategoTerm arg124 = term.getSubterm(0);
                if(arg124.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg124).getConstructor())
                  break Fail706;
                n_454 = arg124.getSubterm(0);
                IStrategoTerm arg125 = term.getSubterm(1);
                if(arg125.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg125).getConstructor())
                  break Fail706;
                o_454 = arg125.getSubterm(0);
                term = termFactory.makeTuple(n_454, o_454);
                term = mul$S_0_0.instance.invoke(context, term);
                if(term == null)
                  break Fail706;
                p_454 = term;
                term = s_480.instance.invoke(context, p_454, t_480);
                if(term == null)
                  break Fail706;
                term = termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{term});
                if(true)
                  break Success490;
              }
              term = term126;
            }
            Success491:
            { 
              if(cons80 == Simplify._consMul_2)
              { 
                Fail707:
                { 
                  IStrategoTerm t_454 = null;
                  IStrategoTerm u_454 = null;
                  IStrategoTerm v_454 = null;
                  IStrategoTerm w_454 = null;
                  IStrategoTerm arg126 = term.getSubterm(0);
                  if(arg126.getTermType() != IStrategoTerm.APPL || Simplify._consMul_2 != ((IStrategoAppl)arg126).getConstructor())
                    break Fail707;
                  t_454 = arg126.getSubterm(0);
                  IStrategoTerm arg127 = arg126.getSubterm(1);
                  if(arg127.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg127).getConstructor())
                    break Fail707;
                  u_454 = arg127.getSubterm(0);
                  IStrategoTerm arg128 = term.getSubterm(1);
                  if(arg128.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg128).getConstructor())
                    break Fail707;
                  v_454 = arg128.getSubterm(0);
                  term = termFactory.makeTuple(u_454, v_454);
                  term = mul$S_0_0.instance.invoke(context, term);
                  if(term == null)
                    break Fail707;
                  w_454 = term;
                  term = s_480.instance.invoke(context, w_454, t_480);
                  if(term == null)
                    break Fail707;
                  term = termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{t_454, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{term})});
                  term = t_480.invoke(context, term);
                  if(term == null)
                    break Fail707;
                  if(true)
                    break Success491;
                }
                term = term126;
              }
              Success492:
              { 
                if(cons80 == Simplify._consMul_2)
                { 
                  Fail708:
                  { 
                    IStrategoTerm a_455 = null;
                    IStrategoTerm b_455 = null;
                    IStrategoTerm arg129 = term.getSubterm(0);
                    if(arg129.getTermType() != IStrategoTerm.APPL || Simplify._consDiv_2 != ((IStrategoAppl)arg129).getConstructor())
                      break Fail708;
                    a_455 = arg129.getSubterm(0);
                    b_455 = arg129.getSubterm(1);
                    IStrategoTerm arg130 = term.getSubterm(1);
                    if(arg130.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg130).getConstructor())
                      break Fail708;
                    IStrategoTerm arg131 = arg130.getSubterm(0);
                    if(arg131.getTermType() != IStrategoTerm.STRING || !"-1".equals(((IStrategoString)arg131).stringValue()))
                      break Fail708;
                    term = termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{a_455, Simplify.constInt2});
                    term = t_480.invoke(context, term);
                    if(term == null)
                      break Fail708;
                    term = termFactory.makeAppl(Simplify._consDiv_2, new IStrategoTerm[]{term, b_455});
                    term = t_480.invoke(context, term);
                    if(term == null)
                      break Fail708;
                    if(true)
                      break Success492;
                  }
                  term = term126;
                }
                Success493:
                { 
                  if(cons80 == Simplify._consDiv_2)
                  { 
                    Fail709:
                    { 
                      IStrategoTerm e_455 = null;
                      IStrategoTerm f_455 = null;
                      IStrategoTerm g_455 = null;
                      IStrategoTerm arg132 = term.getSubterm(0);
                      if(arg132.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg132).getConstructor())
                        break Fail709;
                      e_455 = arg132.getSubterm(0);
                      IStrategoTerm arg133 = term.getSubterm(1);
                      if(arg133.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg133).getConstructor())
                        break Fail709;
                      f_455 = arg133.getSubterm(0);
                      term = termFactory.makeTuple(e_455, f_455);
                      term = mod$S_0_0.instance.invoke(context, term);
                      if(term == null)
                        break Fail709;
                      if(term.getTermType() != IStrategoTerm.STRING || !"0".equals(((IStrategoString)term).stringValue()))
                        break Fail709;
                      term = termFactory.makeTuple(e_455, f_455);
                      term = div$S_0_0.instance.invoke(context, term);
                      if(term == null)
                        break Fail709;
                      g_455 = term;
                      term = s_480.instance.invoke(context, g_455, t_480);
                      if(term == null)
                        break Fail709;
                      term = termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{term});
                      if(true)
                        break Success493;
                    }
                    term = term126;
                  }
                  Success494:
                  { 
                    if(cons80 == Simplify._consDiv_2)
                    { 
                      Fail710:
                      { 
                        IStrategoTerm k_455 = null;
                        IStrategoTerm l_455 = null;
                        IStrategoTerm m_455 = null;
                        IStrategoTerm n_455 = null;
                        IStrategoTerm arg134 = term.getSubterm(0);
                        if(arg134.getTermType() != IStrategoTerm.APPL || Simplify._consMul_2 != ((IStrategoAppl)arg134).getConstructor())
                          break Fail710;
                        k_455 = arg134.getSubterm(0);
                        IStrategoTerm arg135 = arg134.getSubterm(1);
                        if(arg135.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg135).getConstructor())
                          break Fail710;
                        l_455 = arg135.getSubterm(0);
                        IStrategoTerm arg136 = term.getSubterm(1);
                        if(arg136.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg136).getConstructor())
                          break Fail710;
                        m_455 = arg136.getSubterm(0);
                        term = termFactory.makeTuple(l_455, m_455);
                        term = mod$S_0_0.instance.invoke(context, term);
                        if(term == null)
                          break Fail710;
                        if(term.getTermType() != IStrategoTerm.STRING || !"0".equals(((IStrategoString)term).stringValue()))
                          break Fail710;
                        term = termFactory.makeTuple(l_455, m_455);
                        term = div$S_0_0.instance.invoke(context, term);
                        if(term == null)
                          break Fail710;
                        n_455 = term;
                        term = s_480.instance.invoke(context, n_455, t_480);
                        if(term == null)
                          break Fail710;
                        term = termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{k_455, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{term})});
                        term = t_480.invoke(context, term);
                        if(term == null)
                          break Fail710;
                        if(true)
                          break Success494;
                      }
                      term = term126;
                    }
                    Success495:
                    { 
                      if(cons80 == Simplify._consMul_2)
                      { 
                        Fail711:
                        { 
                          IStrategoTerm r_455 = null;
                          IStrategoTerm s_455 = null;
                          IStrategoTerm t_455 = null;
                          IStrategoTerm u_455 = null;
                          IStrategoTerm w_455 = null;
                          IStrategoTerm arg137 = term.getSubterm(0);
                          if(arg137.getTermType() != IStrategoTerm.APPL || Simplify._consAdd_2 != ((IStrategoAppl)arg137).getConstructor())
                            break Fail711;
                          r_455 = arg137.getSubterm(0);
                          IStrategoTerm arg138 = arg137.getSubterm(1);
                          if(arg138.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg138).getConstructor())
                            break Fail711;
                          s_455 = arg138.getSubterm(0);
                          IStrategoTerm arg139 = term.getSubterm(1);
                          if(arg139.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg139).getConstructor())
                            break Fail711;
                          t_455 = arg139.getSubterm(0);
                          term = termFactory.makeTuple(s_455, t_455);
                          term = mul$S_0_0.instance.invoke(context, term);
                          if(term == null)
                            break Fail711;
                          u_455 = term;
                          term = termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{r_455, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{t_455})});
                          term = t_480.invoke(context, term);
                          if(term == null)
                            break Fail711;
                          w_455 = term;
                          term = s_480.instance.invoke(context, u_455, t_480);
                          if(term == null)
                            break Fail711;
                          term = termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{w_455, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{term})});
                          term = t_480.invoke(context, term);
                          if(term == null)
                            break Fail711;
                          if(true)
                            break Success495;
                        }
                        term = term126;
                      }
                      Success496:
                      { 
                        if(cons80 == Simplify._consAdd_2)
                        { 
                          Fail712:
                          { 
                            IStrategoTerm a_456 = null;
                            IStrategoTerm b_456 = null;
                            IStrategoTerm c_456 = null;
                            IStrategoTerm d_456 = null;
                            IStrategoTerm arg140 = term.getSubterm(0);
                            if(arg140.getTermType() != IStrategoTerm.APPL || Simplify._consMul_2 != ((IStrategoAppl)arg140).getConstructor())
                              break Fail712;
                            a_456 = arg140.getSubterm(0);
                            IStrategoTerm arg141 = arg140.getSubterm(1);
                            if(arg141.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg141).getConstructor())
                              break Fail712;
                            b_456 = arg141.getSubterm(0);
                            IStrategoTerm arg142 = term.getSubterm(1);
                            if(arg142.getTermType() != IStrategoTerm.APPL || Simplify._consMul_2 != ((IStrategoAppl)arg142).getConstructor())
                              break Fail712;
                            if(arg142.getSubterm(0) != a_456 && !a_456.match(arg142.getSubterm(0)))
                              break Fail712;
                            IStrategoTerm arg143 = arg142.getSubterm(1);
                            if(arg143.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg143).getConstructor())
                              break Fail712;
                            c_456 = arg143.getSubterm(0);
                            term = termFactory.makeTuple(b_456, c_456);
                            term = add$S_0_0.instance.invoke(context, term);
                            if(term == null)
                              break Fail712;
                            d_456 = term;
                            term = s_480.instance.invoke(context, d_456, t_480);
                            if(term == null)
                              break Fail712;
                            term = termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{a_456, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{term})});
                            term = t_480.invoke(context, term);
                            if(term == null)
                              break Fail712;
                            if(true)
                              break Success496;
                          }
                          term = term126;
                        }
                        Success497:
                        { 
                          if(cons80 == Simplify._consAdd_2)
                          { 
                            Fail713:
                            { 
                              IStrategoTerm h_456 = null;
                              IStrategoTerm i_456 = null;
                              IStrategoTerm j_456 = null;
                              IStrategoTerm k_456 = null;
                              IStrategoTerm l_456 = null;
                              IStrategoTerm arg144 = term.getSubterm(0);
                              if(arg144.getTermType() != IStrategoTerm.APPL || Simplify._consAdd_2 != ((IStrategoAppl)arg144).getConstructor())
                                break Fail713;
                              h_456 = arg144.getSubterm(0);
                              IStrategoTerm arg145 = arg144.getSubterm(1);
                              if(arg145.getTermType() != IStrategoTerm.APPL || Simplify._consMul_2 != ((IStrategoAppl)arg145).getConstructor())
                                break Fail713;
                              i_456 = arg145.getSubterm(0);
                              IStrategoTerm arg146 = arg145.getSubterm(1);
                              if(arg146.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg146).getConstructor())
                                break Fail713;
                              j_456 = arg146.getSubterm(0);
                              IStrategoTerm arg147 = term.getSubterm(1);
                              if(arg147.getTermType() != IStrategoTerm.APPL || Simplify._consMul_2 != ((IStrategoAppl)arg147).getConstructor())
                                break Fail713;
                              if(arg147.getSubterm(0) != i_456 && !i_456.match(arg147.getSubterm(0)))
                                break Fail713;
                              IStrategoTerm arg148 = arg147.getSubterm(1);
                              if(arg148.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg148).getConstructor())
                                break Fail713;
                              k_456 = arg148.getSubterm(0);
                              term = termFactory.makeTuple(j_456, k_456);
                              term = add$S_0_0.instance.invoke(context, term);
                              if(term == null)
                                break Fail713;
                              l_456 = term;
                              term = s_480.instance.invoke(context, l_456, t_480);
                              if(term == null)
                                break Fail713;
                              term = termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{i_456, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{term})});
                              term = t_480.invoke(context, term);
                              if(term == null)
                                break Fail713;
                              term = termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{h_456, term});
                              term = t_480.invoke(context, term);
                              if(term == null)
                                break Fail713;
                              if(true)
                                break Success497;
                            }
                            term = term126;
                          }
                          Success498:
                          { 
                            if(cons80 == Simplify._consDiv_2)
                            { 
                              Fail714:
                              { 
                                IStrategoTerm r_456 = null;
                                r_456 = term.getSubterm(0);
                                if(term.getSubterm(1) != r_456 && !r_456.match(term.getSubterm(1)))
                                  break Fail714;
                                term = Simplify.constInt0;
                                if(true)
                                  break Success498;
                              }
                              term = term126;
                            }
                            Success499:
                            { 
                              if(cons80 == Simplify._consDiv_2)
                              { 
                                Fail715:
                                { 
                                  IStrategoTerm s_456 = null;
                                  IStrategoTerm t_456 = null;
                                  IStrategoTerm arg149 = term.getSubterm(0);
                                  if(arg149.getTermType() != IStrategoTerm.APPL || Simplify._consMul_2 != ((IStrategoAppl)arg149).getConstructor())
                                    break Fail715;
                                  s_456 = arg149.getSubterm(0);
                                  IStrategoTerm arg150 = arg149.getSubterm(1);
                                  if(arg150.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg150).getConstructor())
                                    break Fail715;
                                  t_456 = arg150.getSubterm(0);
                                  if(term.getSubterm(1) != s_456 && !s_456.match(term.getSubterm(1)))
                                    break Fail715;
                                  term = termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{t_456});
                                  if(true)
                                    break Success499;
                                }
                                term = term126;
                              }
                              Success500:
                              { 
                                if(cons80 == Simplify._consDiv_2)
                                { 
                                  Fail716:
                                  { 
                                    IStrategoTerm u_456 = null;
                                    IStrategoTerm v_456 = null;
                                    u_456 = term.getSubterm(0);
                                    IStrategoTerm arg151 = term.getSubterm(1);
                                    if(arg151.getTermType() != IStrategoTerm.APPL || Simplify._consMul_2 != ((IStrategoAppl)arg151).getConstructor())
                                      break Fail716;
                                    if(arg151.getSubterm(0) != u_456 && !u_456.match(arg151.getSubterm(0)))
                                      break Fail716;
                                    IStrategoTerm arg152 = arg151.getSubterm(1);
                                    if(arg152.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg152).getConstructor())
                                      break Fail716;
                                    v_456 = arg152.getSubterm(0);
                                    term = termFactory.makeAppl(Simplify._consDiv_2, new IStrategoTerm[]{Simplify.constInt0, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{v_456})});
                                    term = t_480.invoke(context, term);
                                    if(term == null)
                                      break Fail716;
                                    if(true)
                                      break Success500;
                                  }
                                  term = term126;
                                }
                                Success501:
                                { 
                                  if(cons80 == Simplify._consDiv_2)
                                  { 
                                    Fail717:
                                    { 
                                      IStrategoTerm w_456 = null;
                                      IStrategoTerm x_456 = null;
                                      IStrategoTerm y_456 = null;
                                      IStrategoTerm arg153 = term.getSubterm(0);
                                      if(arg153.getTermType() != IStrategoTerm.APPL || Simplify._consMul_2 != ((IStrategoAppl)arg153).getConstructor())
                                        break Fail717;
                                      w_456 = arg153.getSubterm(0);
                                      IStrategoTerm arg154 = arg153.getSubterm(1);
                                      if(arg154.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg154).getConstructor())
                                        break Fail717;
                                      x_456 = arg154.getSubterm(0);
                                      IStrategoTerm arg155 = term.getSubterm(1);
                                      if(arg155.getTermType() != IStrategoTerm.APPL || Simplify._consMul_2 != ((IStrategoAppl)arg155).getConstructor())
                                        break Fail717;
                                      if(arg155.getSubterm(0) != w_456 && !w_456.match(arg155.getSubterm(0)))
                                        break Fail717;
                                      IStrategoTerm arg156 = arg155.getSubterm(1);
                                      if(arg156.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg156).getConstructor())
                                        break Fail717;
                                      y_456 = arg156.getSubterm(0);
                                      term = termFactory.makeAppl(Simplify._consDiv_2, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{x_456}), termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{y_456})});
                                      term = t_480.invoke(context, term);
                                      if(term == null)
                                        break Fail717;
                                      if(true)
                                        break Success501;
                                    }
                                    term = term126;
                                  }
                                  Success502:
                                  { 
                                    if(cons80 == Simplify._consDiv_2)
                                    { 
                                      Fail718:
                                      { 
                                        IStrategoTerm z_456 = null;
                                        IStrategoTerm a_457 = null;
                                        IStrategoTerm b_457 = null;
                                        IStrategoTerm arg157 = term.getSubterm(0);
                                        if(arg157.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg157).getConstructor())
                                          break Fail718;
                                        z_456 = arg157.getSubterm(0);
                                        IStrategoTerm arg158 = term.getSubterm(1);
                                        if(arg158.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg158).getConstructor())
                                          break Fail718;
                                        a_457 = arg158.getSubterm(0);
                                        term = termFactory.makeTuple(z_456, a_457);
                                        term = div$S_0_0.instance.invoke(context, term);
                                        if(term == null)
                                          break Fail718;
                                        b_457 = term;
                                        term = s_480.instance.invoke(context, b_457, t_480);
                                        if(term == null)
                                          break Fail718;
                                        term = termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{term});
                                        if(true)
                                          break Success502;
                                      }
                                      term = term126;
                                    }
                                    Success503:
                                    { 
                                      if(cons80 == Simplify._consDiv_2)
                                      { 
                                        Fail719:
                                        { 
                                          IStrategoTerm f_457 = null;
                                          IStrategoTerm g_457 = null;
                                          IStrategoTerm h_457 = null;
                                          IStrategoTerm i_457 = null;
                                          IStrategoTerm arg159 = term.getSubterm(0);
                                          if(arg159.getTermType() != IStrategoTerm.APPL || Simplify._consDiv_2 != ((IStrategoAppl)arg159).getConstructor())
                                            break Fail719;
                                          f_457 = arg159.getSubterm(0);
                                          IStrategoTerm arg160 = arg159.getSubterm(1);
                                          if(arg160.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg160).getConstructor())
                                            break Fail719;
                                          g_457 = arg160.getSubterm(0);
                                          IStrategoTerm arg161 = term.getSubterm(1);
                                          if(arg161.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg161).getConstructor())
                                            break Fail719;
                                          h_457 = arg161.getSubterm(0);
                                          term = termFactory.makeTuple(g_457, h_457);
                                          term = mul$S_0_0.instance.invoke(context, term);
                                          if(term == null)
                                            break Fail719;
                                          i_457 = term;
                                          term = s_480.instance.invoke(context, i_457, t_480);
                                          if(term == null)
                                            break Fail719;
                                          term = termFactory.makeAppl(Simplify._consDiv_2, new IStrategoTerm[]{f_457, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{term})});
                                          term = t_480.invoke(context, term);
                                          if(term == null)
                                            break Fail719;
                                          if(true)
                                            break Success503;
                                        }
                                        term = term126;
                                      }
                                      Success504:
                                      { 
                                        if(cons80 == Simplify._consMod_2)
                                        { 
                                          Fail720:
                                          { 
                                            IStrategoTerm m_457 = null;
                                            IStrategoTerm n_457 = null;
                                            IStrategoTerm o_457 = null;
                                            IStrategoTerm arg162 = term.getSubterm(0);
                                            if(arg162.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg162).getConstructor())
                                              break Fail720;
                                            m_457 = arg162.getSubterm(0);
                                            IStrategoTerm arg163 = term.getSubterm(1);
                                            if(arg163.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg163).getConstructor())
                                              break Fail720;
                                            n_457 = arg163.getSubterm(0);
                                            term = termFactory.makeTuple(m_457, n_457);
                                            term = mod$S_0_0.instance.invoke(context, term);
                                            if(term == null)
                                              break Fail720;
                                            o_457 = term;
                                            term = s_480.instance.invoke(context, o_457, t_480);
                                            if(term == null)
                                              break Fail720;
                                            term = termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{term});
                                            if(true)
                                              break Success504;
                                          }
                                          term = term126;
                                        }
                                        Success505:
                                        { 
                                          if(cons80 == Simplify._consLt_2)
                                          { 
                                            Fail721:
                                            { 
                                              IStrategoTerm s_457 = null;
                                              IStrategoTerm t_457 = null;
                                              IStrategoTerm arg164 = term.getSubterm(0);
                                              if(arg164.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg164).getConstructor())
                                                break Fail721;
                                              s_457 = arg164.getSubterm(0);
                                              IStrategoTerm arg165 = term.getSubterm(1);
                                              if(arg165.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg165).getConstructor())
                                                break Fail721;
                                              t_457 = arg165.getSubterm(0);
                                              term = termFactory.makeTuple(s_457, t_457);
                                              term = compare_1_0.instance.invoke(context, term, lt$S_0_0.instance);
                                              if(term == null)
                                                break Fail721;
                                              term = s_480.instance.invoke(context, term, t_480);
                                              if(term == null)
                                                break Fail721;
                                              if(true)
                                                break Success505;
                                            }
                                            term = term126;
                                          }
                                          Success506:
                                          { 
                                            if(cons80 == Simplify._consGt_2)
                                            { 
                                              Fail722:
                                              { 
                                                IStrategoTerm u_457 = null;
                                                IStrategoTerm v_457 = null;
                                                IStrategoTerm arg166 = term.getSubterm(0);
                                                if(arg166.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg166).getConstructor())
                                                  break Fail722;
                                                u_457 = arg166.getSubterm(0);
                                                IStrategoTerm arg167 = term.getSubterm(1);
                                                if(arg167.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg167).getConstructor())
                                                  break Fail722;
                                                v_457 = arg167.getSubterm(0);
                                                term = termFactory.makeTuple(u_457, v_457);
                                                term = compare_1_0.instance.invoke(context, term, gt$S_0_0.instance);
                                                if(term == null)
                                                  break Fail722;
                                                term = s_480.instance.invoke(context, term, t_480);
                                                if(term == null)
                                                  break Fail722;
                                                if(true)
                                                  break Success506;
                                              }
                                              term = term126;
                                            }
                                            Success507:
                                            { 
                                              if(cons80 == Simplify._consLeq_2)
                                              { 
                                                Fail723:
                                                { 
                                                  IStrategoTerm w_457 = null;
                                                  IStrategoTerm x_457 = null;
                                                  IStrategoTerm arg168 = term.getSubterm(0);
                                                  if(arg168.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg168).getConstructor())
                                                    break Fail723;
                                                  w_457 = arg168.getSubterm(0);
                                                  IStrategoTerm arg169 = term.getSubterm(1);
                                                  if(arg169.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg169).getConstructor())
                                                    break Fail723;
                                                  x_457 = arg169.getSubterm(0);
                                                  term = termFactory.makeTuple(w_457, x_457);
                                                  term = compare_1_0.instance.invoke(context, term, leq$S_0_0.instance);
                                                  if(term == null)
                                                    break Fail723;
                                                  term = s_480.instance.invoke(context, term, t_480);
                                                  if(term == null)
                                                    break Fail723;
                                                  if(true)
                                                    break Success507;
                                                }
                                                term = term126;
                                              }
                                              Success508:
                                              { 
                                                if(cons80 == Simplify._consGeq_2)
                                                { 
                                                  Fail724:
                                                  { 
                                                    IStrategoTerm y_457 = null;
                                                    IStrategoTerm z_457 = null;
                                                    IStrategoTerm arg170 = term.getSubterm(0);
                                                    if(arg170.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg170).getConstructor())
                                                      break Fail724;
                                                    y_457 = arg170.getSubterm(0);
                                                    IStrategoTerm arg171 = term.getSubterm(1);
                                                    if(arg171.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg171).getConstructor())
                                                      break Fail724;
                                                    z_457 = arg171.getSubterm(0);
                                                    term = termFactory.makeTuple(y_457, z_457);
                                                    term = compare_1_0.instance.invoke(context, term, geq$S_0_0.instance);
                                                    if(term == null)
                                                      break Fail724;
                                                    term = s_480.instance.invoke(context, term, t_480);
                                                    if(term == null)
                                                      break Fail724;
                                                    if(true)
                                                      break Success508;
                                                  }
                                                  term = term126;
                                                }
                                                Success509:
                                                { 
                                                  if(cons80 == Simplify._consEqu_2)
                                                  { 
                                                    Fail725:
                                                    { 
                                                      IStrategoTerm a_458 = null;
                                                      IStrategoTerm b_458 = null;
                                                      IStrategoTerm arg172 = term.getSubterm(0);
                                                      if(arg172.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg172).getConstructor())
                                                        break Fail725;
                                                      a_458 = arg172.getSubterm(0);
                                                      IStrategoTerm arg173 = term.getSubterm(1);
                                                      if(arg173.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg173).getConstructor())
                                                        break Fail725;
                                                      b_458 = arg173.getSubterm(0);
                                                      term = termFactory.makeTuple(a_458, b_458);
                                                      term = compare_1_0.instance.invoke(context, term, eq_0_0.instance);
                                                      if(term == null)
                                                        break Fail725;
                                                      term = s_480.instance.invoke(context, term, t_480);
                                                      if(term == null)
                                                        break Fail725;
                                                      if(true)
                                                        break Success509;
                                                    }
                                                    term = term126;
                                                  }
                                                  Success510:
                                                  { 
                                                    if(cons80 == Simplify._consNeq_2)
                                                    { 
                                                      Fail726:
                                                      { 
                                                        IStrategoTerm c_458 = null;
                                                        IStrategoTerm d_458 = null;
                                                        IStrategoTerm arg174 = term.getSubterm(0);
                                                        if(arg174.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg174).getConstructor())
                                                          break Fail726;
                                                        c_458 = arg174.getSubterm(0);
                                                        IStrategoTerm arg175 = term.getSubterm(1);
                                                        if(arg175.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg175).getConstructor())
                                                          break Fail726;
                                                        d_458 = arg175.getSubterm(0);
                                                        term = termFactory.makeTuple(c_458, d_458);
                                                        term = compare_1_0.instance.invoke(context, term, lifted137.instance);
                                                        if(term == null)
                                                          break Fail726;
                                                        term = s_480.instance.invoke(context, term, t_480);
                                                        if(term == null)
                                                          break Fail726;
                                                        if(true)
                                                          break Success510;
                                                      }
                                                      term = term126;
                                                    }
                                                    Success511:
                                                    { 
                                                      if(cons80 == Simplify._consDiv_2)
                                                      { 
                                                        Fail727:
                                                        { 
                                                          IStrategoTerm e_458 = null;
                                                          e_458 = term.getSubterm(0);
                                                          IStrategoTerm arg176 = term.getSubterm(1);
                                                          if(arg176.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg176).getConstructor())
                                                            break Fail727;
                                                          IStrategoTerm arg177 = arg176.getSubterm(0);
                                                          if(arg177.getTermType() != IStrategoTerm.STRING || !"1".equals(((IStrategoString)arg177).stringValue()))
                                                            break Fail727;
                                                          term = e_458;
                                                          if(true)
                                                            break Success511;
                                                        }
                                                        term = term126;
                                                      }
                                                      Success512:
                                                      { 
                                                        if(cons80 == Simplify._consMul_2)
                                                        { 
                                                          Fail728:
                                                          { 
                                                            IStrategoTerm arg178 = term.getSubterm(1);
                                                            if(arg178.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg178).getConstructor())
                                                              break Fail728;
                                                            IStrategoTerm arg179 = arg178.getSubterm(0);
                                                            if(arg179.getTermType() != IStrategoTerm.STRING || !"0".equals(((IStrategoString)arg179).stringValue()))
                                                              break Fail728;
                                                            term = Simplify.constInt3;
                                                            if(true)
                                                              break Success512;
                                                          }
                                                          term = term126;
                                                        }
                                                        Success513:
                                                        { 
                                                          if(cons80 == Simplify._consMul_2)
                                                          { 
                                                            Fail729:
                                                            { 
                                                              IStrategoTerm arg180 = term.getSubterm(0);
                                                              if(arg180.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg180).getConstructor())
                                                                break Fail729;
                                                              IStrategoTerm arg181 = arg180.getSubterm(0);
                                                              if(arg181.getTermType() != IStrategoTerm.STRING || !"0".equals(((IStrategoString)arg181).stringValue()))
                                                                break Fail729;
                                                              term = Simplify.constInt3;
                                                              if(true)
                                                                break Success513;
                                                            }
                                                            term = term126;
                                                          }
                                                          Success514:
                                                          { 
                                                            if(cons80 == Simplify._consDiv_2)
                                                            { 
                                                              Fail730:
                                                              { 
                                                                IStrategoTerm arg182 = term.getSubterm(0);
                                                                if(arg182.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg182).getConstructor())
                                                                  break Fail730;
                                                                IStrategoTerm arg183 = arg182.getSubterm(0);
                                                                if(arg183.getTermType() != IStrategoTerm.STRING || !"0".equals(((IStrategoString)arg183).stringValue()))
                                                                  break Fail730;
                                                                term = Simplify.constInt3;
                                                                if(true)
                                                                  break Success514;
                                                              }
                                                              term = term126;
                                                            }
                                                            Success515:
                                                            { 
                                                              if(cons80 == Simplify._consOr_2)
                                                              { 
                                                                Fail731:
                                                                { 
                                                                  IStrategoTerm arg184 = term.getSubterm(0);
                                                                  if(arg184.getTermType() != IStrategoTerm.APPL || Simplify._consTrue_0 != ((IStrategoAppl)arg184).getConstructor())
                                                                    break Fail731;
                                                                  term = Simplify.constTrue0;
                                                                  if(true)
                                                                    break Success515;
                                                                }
                                                                term = term126;
                                                              }
                                                              Success516:
                                                              { 
                                                                if(cons80 == Simplify._consOr_2)
                                                                { 
                                                                  Fail732:
                                                                  { 
                                                                    IStrategoTerm arg185 = term.getSubterm(1);
                                                                    if(arg185.getTermType() != IStrategoTerm.APPL || Simplify._consTrue_0 != ((IStrategoAppl)arg185).getConstructor())
                                                                      break Fail732;
                                                                    term = Simplify.constTrue0;
                                                                    if(true)
                                                                      break Success516;
                                                                  }
                                                                  term = term126;
                                                                }
                                                                Success517:
                                                                { 
                                                                  if(cons80 == Simplify._consOr_2)
                                                                  { 
                                                                    Fail733:
                                                                    { 
                                                                      IStrategoTerm k_458 = null;
                                                                      k_458 = term.getSubterm(0);
                                                                      IStrategoTerm arg186 = term.getSubterm(1);
                                                                      if(arg186.getTermType() != IStrategoTerm.APPL || Simplify._consFalse_0 != ((IStrategoAppl)arg186).getConstructor())
                                                                        break Fail733;
                                                                      term = k_458;
                                                                      if(true)
                                                                        break Success517;
                                                                    }
                                                                    term = term126;
                                                                  }
                                                                  Success518:
                                                                  { 
                                                                    if(cons80 == Simplify._consOr_2)
                                                                    { 
                                                                      Fail734:
                                                                      { 
                                                                        IStrategoTerm l_458 = null;
                                                                        IStrategoTerm arg187 = term.getSubterm(0);
                                                                        if(arg187.getTermType() != IStrategoTerm.APPL || Simplify._consFalse_0 != ((IStrategoAppl)arg187).getConstructor())
                                                                          break Fail734;
                                                                        l_458 = term.getSubterm(1);
                                                                        term = l_458;
                                                                        if(true)
                                                                          break Success518;
                                                                      }
                                                                      term = term126;
                                                                    }
                                                                    Success519:
                                                                    { 
                                                                      if(cons80 == Simplify._consAnd_2)
                                                                      { 
                                                                        Fail735:
                                                                        { 
                                                                          IStrategoTerm m_458 = null;
                                                                          m_458 = term.getSubterm(0);
                                                                          IStrategoTerm arg188 = term.getSubterm(1);
                                                                          if(arg188.getTermType() != IStrategoTerm.APPL || Simplify._consTrue_0 != ((IStrategoAppl)arg188).getConstructor())
                                                                            break Fail735;
                                                                          term = m_458;
                                                                          if(true)
                                                                            break Success519;
                                                                        }
                                                                        term = term126;
                                                                      }
                                                                      Success520:
                                                                      { 
                                                                        if(cons80 == Simplify._consAnd_2)
                                                                        { 
                                                                          Fail736:
                                                                          { 
                                                                            IStrategoTerm n_458 = null;
                                                                            IStrategoTerm arg189 = term.getSubterm(0);
                                                                            if(arg189.getTermType() != IStrategoTerm.APPL || Simplify._consTrue_0 != ((IStrategoAppl)arg189).getConstructor())
                                                                              break Fail736;
                                                                            n_458 = term.getSubterm(1);
                                                                            term = n_458;
                                                                            if(true)
                                                                              break Success520;
                                                                          }
                                                                          term = term126;
                                                                        }
                                                                        Success521:
                                                                        { 
                                                                          if(cons80 == Simplify._consAnd_2)
                                                                          { 
                                                                            Fail737:
                                                                            { 
                                                                              IStrategoTerm arg190 = term.getSubterm(1);
                                                                              if(arg190.getTermType() != IStrategoTerm.APPL || Simplify._consFalse_0 != ((IStrategoAppl)arg190).getConstructor())
                                                                                break Fail737;
                                                                              term = Simplify.constFalse0;
                                                                              if(true)
                                                                                break Success521;
                                                                            }
                                                                            term = term126;
                                                                          }
                                                                          Success522:
                                                                          { 
                                                                            if(cons80 == Simplify._consAnd_2)
                                                                            { 
                                                                              Fail738:
                                                                              { 
                                                                                IStrategoTerm arg191 = term.getSubterm(0);
                                                                                if(arg191.getTermType() != IStrategoTerm.APPL || Simplify._consFalse_0 != ((IStrategoAppl)arg191).getConstructor())
                                                                                  break Fail738;
                                                                                term = Simplify.constFalse0;
                                                                                if(true)
                                                                                  break Success522;
                                                                              }
                                                                              term = term126;
                                                                            }
                                                                            Success523:
                                                                            { 
                                                                              if(cons80 == Simplify._consNot_1)
                                                                              { 
                                                                                Fail739:
                                                                                { 
                                                                                  IStrategoTerm arg192 = term.getSubterm(0);
                                                                                  if(arg192.getTermType() != IStrategoTerm.APPL || Simplify._consTrue_0 != ((IStrategoAppl)arg192).getConstructor())
                                                                                    break Fail739;
                                                                                  term = Simplify.constFalse0;
                                                                                  if(true)
                                                                                    break Success523;
                                                                                }
                                                                                term = term126;
                                                                              }
                                                                              Success524:
                                                                              { 
                                                                                if(cons80 == Simplify._consNot_1)
                                                                                { 
                                                                                  Fail740:
                                                                                  { 
                                                                                    IStrategoTerm arg193 = term.getSubterm(0);
                                                                                    if(arg193.getTermType() != IStrategoTerm.APPL || Simplify._consFalse_0 != ((IStrategoAppl)arg193).getConstructor())
                                                                                      break Fail740;
                                                                                    term = Simplify.constTrue0;
                                                                                    if(true)
                                                                                      break Success524;
                                                                                  }
                                                                                  term = term126;
                                                                                }
                                                                                Success525:
                                                                                { 
                                                                                  if(cons80 == Simplify._consNot_1)
                                                                                  { 
                                                                                    Fail741:
                                                                                    { 
                                                                                      IStrategoTerm q_458 = null;
                                                                                      IStrategoTerm arg194 = term.getSubterm(0);
                                                                                      if(arg194.getTermType() != IStrategoTerm.APPL || Simplify._consNot_1 != ((IStrategoAppl)arg194).getConstructor())
                                                                                        break Fail741;
                                                                                      q_458 = arg194.getSubterm(0);
                                                                                      term = q_458;
                                                                                      if(true)
                                                                                        break Success525;
                                                                                    }
                                                                                    term = term126;
                                                                                  }
                                                                                  Success526:
                                                                                  { 
                                                                                    if(cons80 == Simplify._consIfElseExp_3)
                                                                                    { 
                                                                                      Fail742:
                                                                                      { 
                                                                                        IStrategoTerm s_458 = null;
                                                                                        IStrategoTerm arg195 = term.getSubterm(0);
                                                                                        if(arg195.getTermType() != IStrategoTerm.APPL || Simplify._consFalse_0 != ((IStrategoAppl)arg195).getConstructor())
                                                                                          break Fail742;
                                                                                        s_458 = term.getSubterm(2);
                                                                                        term = s_458;
                                                                                        if(true)
                                                                                          break Success526;
                                                                                      }
                                                                                      term = term126;
                                                                                    }
                                                                                    if(cons80 == Simplify._consIfElseExp_3)
                                                                                    { 
                                                                                      IStrategoTerm u_458 = null;
                                                                                      IStrategoTerm arg196 = term.getSubterm(0);
                                                                                      if(arg196.getTermType() != IStrategoTerm.APPL || Simplify._consTrue_0 != ((IStrategoAppl)arg196).getConstructor())
                                                                                        break Fail704;
                                                                                      u_458 = term.getSubterm(1);
                                                                                      term = u_458;
                                                                                    }
                                                                                    else
                                                                                    { 
                                                                                      break Fail704;
                                                                                    }
                                                                                  }
                                                                                }
                                                                              }
                                                                            }
                                                                          }
                                                                        }
                                                                      }
                                                                    }
                                                                  }
                                                                }
                                                              }
                                                            }
                                                          }
                                                        }
                                                      }
                                                    }
                                                  }
                                                }
                                              }
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted137 extends Strategy 
  { 
    public static final lifted137 instance = new lifted137();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail743:
      { 
        IStrategoTerm term148 = term;
        Success527:
        { 
          Fail744:
          { 
            term = eq_0_0.instance.invoke(context, term);
            if(term == null)
              break Fail744;
            { 
              if(true)
                break Fail743;
              if(true)
                break Success527;
            }
          }
          term = term148;
        }
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class s_480 extends Strategy 
  { 
    public static final s_480 instance = new s_480();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term, Strategy u_480)
    { 
      Fail745:
      { 
        lifted131 lifted1310 = new lifted131();
        lifted1310.u_480 = u_480;
        term = SRTS_all.instance.invoke(context, term, lifted1310);
        if(term == null)
          break Fail745;
        term = u_480.invoke(context, term);
        if(term == null)
          break Fail745;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted131 extends Strategy 
  { 
    Strategy u_480;

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail746:
      { 
        term = s_480.instance.invoke(context, term, u_480);
        if(term == null)
          break Fail746;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted129 extends Strategy 
  { 
    TermReference x_47;

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail747:
      { 
        lifted130 lifted1300 = new lifted130();
        lifted1300.x_47 = x_47;
        term = $Int_1_0.instance.invoke(context, term, lifted1300);
        if(term == null)
          break Fail747;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted130 extends Strategy 
  { 
    TermReference x_47;

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail748:
      { 
        if(x_47.value == null)
          x_47.value = term;
        else
          if(x_47.value != term && !x_47.value.match(term))
            break Fail748;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted128 extends Strategy 
  { 
    TermReference y_47;

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail749:
      { 
        if(y_47.value == null)
          y_47.value = term;
        else
          if(y_47.value != term && !y_47.value.match(term))
            break Fail749;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted126 extends Strategy 
  { 
    TermReference w_46;

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail750:
      { 
        lifted127 lifted1270 = new lifted127();
        lifted1270.w_46 = w_46;
        term = $Int_1_0.instance.invoke(context, term, lifted1270);
        if(term == null)
          break Fail750;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted127 extends Strategy 
  { 
    TermReference w_46;

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail751:
      { 
        if(w_46.value == null)
          w_46.value = term;
        else
          if(w_46.value != term && !w_46.value.match(term))
            break Fail751;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted125 extends Strategy 
  { 
    TermReference x_46;

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail752:
      { 
        if(x_46.value == null)
          x_46.value = term;
        else
          if(x_46.value != term && !x_46.value.match(term))
            break Fail752;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted123 extends Strategy 
  { 
    TermReference y_44;

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail753:
      { 
        lifted124 lifted1240 = new lifted124();
        lifted1240.y_44 = y_44;
        term = $Int_1_0.instance.invoke(context, term, lifted1240);
        if(term == null)
          break Fail753;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted124 extends Strategy 
  { 
    TermReference y_44;

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail754:
      { 
        if(y_44.value == null)
          y_44.value = term;
        else
          if(y_44.value != term && !y_44.value.match(term))
            break Fail754;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted122 extends Strategy 
  { 
    TermReference z_44;

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail755:
      { 
        if(z_44.value == null)
          z_44.value = term;
        else
          if(z_44.value != term && !z_44.value.match(term))
            break Fail755;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted120 extends Strategy 
  { 
    TermReference t_42;

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail756:
      { 
        lifted121 lifted1210 = new lifted121();
        lifted1210.t_42 = t_42;
        term = $Int_1_0.instance.invoke(context, term, lifted1210);
        if(term == null)
          break Fail756;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted121 extends Strategy 
  { 
    TermReference t_42;

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail757:
      { 
        if(t_42.value == null)
          t_42.value = term;
        else
          if(t_42.value != term && !t_42.value.match(term))
            break Fail757;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted119 extends Strategy 
  { 
    TermReference u_42;

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail758:
      { 
        if(u_42.value == null)
          u_42.value = term;
        else
          if(u_42.value != term && !u_42.value.match(term))
            break Fail758;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted117 extends Strategy 
  { 
    TermReference m_38;

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail759:
      { 
        lifted118 lifted1180 = new lifted118();
        lifted1180.m_38 = m_38;
        term = $Int_1_0.instance.invoke(context, term, lifted1180);
        if(term == null)
          break Fail759;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted118 extends Strategy 
  { 
    TermReference m_38;

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail760:
      { 
        if(m_38.value == null)
          m_38.value = term;
        else
          if(m_38.value != term && !m_38.value.match(term))
            break Fail760;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted116 extends Strategy 
  { 
    TermReference n_38;

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail761:
      { 
        if(n_38.value == null)
          n_38.value = term;
        else
          if(n_38.value != term && !n_38.value.match(term))
            break Fail761;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted115 extends Strategy 
  { 
    TermReference x_37;

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      ITermFactory termFactory = context.getFactory();
      Fail762:
      { 
        IStrategoTerm y_37 = null;
        IStrategoTerm z_37 = null;
        IStrategoTerm a_38 = null;
        IStrategoTerm b_38 = null;
        IStrategoTerm d_38 = null;
        IStrategoTerm e_38 = null;
        IStrategoTerm f_38 = null;
        if(term.getTermType() != IStrategoTerm.APPL || Simplify._consVar_1 != ((IStrategoAppl)term).getConstructor())
          break Fail762;
        y_37 = term.getSubterm(0);
        z_37 = term;
        d_38 = term;
        a_38 = Simplify.const64;
        e_38 = d_38;
        term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consVar_1, new IStrategoTerm[]{y_37}), checkListAnnos(termFactory, Simplify.constCons16));
        b_38 = term;
        term = e_38;
        f_38 = e_38;
        if(x_37.value == null)
          break Fail762;
        term = termFactory.makeTuple(Simplify.const65, x_37.value);
        term = dr_add_rule_0_3.instance.invoke(context, f_38, a_38, b_38, term);
        if(term == null)
          break Fail762;
        term = z_37;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted114 extends Strategy 
  { 
    public static final lifted114 instance = new lifted114();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail763:
      { 
        if(term.getTermType() != IStrategoTerm.APPL || Simplify._consVar_1 != ((IStrategoAppl)term).getConstructor())
          break Fail763;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted113 extends Strategy 
  { 
    public static final lifted113 instance = new lifted113();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      ITermFactory termFactory = context.getFactory();
      Fail764:
      { 
        TermReference k_31 = new TermReference();
        IStrategoTerm l_31 = null;
        IStrategoTerm w_32 = null;
        IStrategoTerm y_32 = null;
        IStrategoTerm z_32 = null;
        IStrategoTerm m_31 = null;
        IStrategoTerm a_33 = null;
        IStrategoTerm c_33 = null;
        IStrategoTerm d_33 = null;
        IStrategoTerm n_31 = null;
        IStrategoTerm e_33 = null;
        IStrategoTerm g_33 = null;
        IStrategoTerm h_33 = null;
        IStrategoTerm o_31 = null;
        IStrategoTerm i_33 = null;
        IStrategoTerm k_33 = null;
        IStrategoTerm l_33 = null;
        IStrategoTerm p_31 = null;
        IStrategoTerm m_33 = null;
        IStrategoTerm o_33 = null;
        IStrategoTerm p_33 = null;
        IStrategoTerm q_31 = null;
        IStrategoTerm q_33 = null;
        IStrategoTerm s_33 = null;
        IStrategoTerm t_33 = null;
        IStrategoTerm r_31 = null;
        IStrategoTerm u_33 = null;
        IStrategoTerm w_33 = null;
        IStrategoTerm x_33 = null;
        IStrategoTerm s_31 = null;
        IStrategoTerm y_33 = null;
        IStrategoTerm a_34 = null;
        IStrategoTerm b_34 = null;
        IStrategoTerm t_31 = null;
        IStrategoTerm c_34 = null;
        IStrategoTerm e_34 = null;
        IStrategoTerm f_34 = null;
        IStrategoTerm u_31 = null;
        IStrategoTerm g_34 = null;
        IStrategoTerm i_34 = null;
        IStrategoTerm j_34 = null;
        TermReference v_31 = new TermReference();
        TermReference k_34 = new TermReference();
        TermReference l_34 = new TermReference();
        IStrategoTerm m_34 = null;
        IStrategoTerm n_34 = null;
        TermReference w_31 = new TermReference();
        TermReference o_34 = new TermReference();
        TermReference p_34 = new TermReference();
        TermReference q_34 = new TermReference();
        TermReference r_34 = new TermReference();
        TermReference x_31 = new TermReference();
        TermReference s_34 = new TermReference();
        TermReference t_34 = new TermReference();
        TermReference u_34 = new TermReference();
        TermReference v_34 = new TermReference();
        TermReference y_31 = new TermReference();
        TermReference w_34 = new TermReference();
        TermReference x_34 = new TermReference();
        TermReference y_34 = new TermReference();
        TermReference z_34 = new TermReference();
        TermReference z_31 = new TermReference();
        TermReference a_35 = new TermReference();
        TermReference b_35 = new TermReference();
        TermReference c_35 = new TermReference();
        TermReference d_35 = new TermReference();
        TermReference a_32 = new TermReference();
        TermReference e_35 = new TermReference();
        TermReference f_35 = new TermReference();
        TermReference g_35 = new TermReference();
        TermReference h_35 = new TermReference();
        TermReference b_32 = new TermReference();
        TermReference i_35 = new TermReference();
        TermReference j_35 = new TermReference();
        TermReference k_35 = new TermReference();
        TermReference l_35 = new TermReference();
        TermReference c_32 = new TermReference();
        TermReference m_35 = new TermReference();
        TermReference n_35 = new TermReference();
        TermReference o_35 = new TermReference();
        TermReference p_35 = new TermReference();
        TermReference d_32 = new TermReference();
        TermReference q_35 = new TermReference();
        TermReference r_35 = new TermReference();
        TermReference s_35 = new TermReference();
        TermReference t_35 = new TermReference();
        TermReference e_32 = new TermReference();
        TermReference u_35 = new TermReference();
        TermReference v_35 = new TermReference();
        TermReference w_35 = new TermReference();
        TermReference x_35 = new TermReference();
        TermReference f_32 = new TermReference();
        TermReference y_35 = new TermReference();
        TermReference z_35 = new TermReference();
        TermReference a_36 = new TermReference();
        TermReference b_36 = new TermReference();
        TermReference g_32 = new TermReference();
        TermReference c_36 = new TermReference();
        TermReference d_36 = new TermReference();
        TermReference e_36 = new TermReference();
        TermReference f_36 = new TermReference();
        TermReference h_32 = new TermReference();
        TermReference g_36 = new TermReference();
        TermReference h_36 = new TermReference();
        TermReference i_36 = new TermReference();
        TermReference j_36 = new TermReference();
        TermReference i_32 = new TermReference();
        TermReference k_36 = new TermReference();
        TermReference l_36 = new TermReference();
        TermReference m_36 = new TermReference();
        TermReference n_36 = new TermReference();
        TermReference j_32 = new TermReference();
        TermReference o_36 = new TermReference();
        TermReference p_36 = new TermReference();
        TermReference q_36 = new TermReference();
        TermReference r_36 = new TermReference();
        TermReference k_32 = new TermReference();
        TermReference s_36 = new TermReference();
        TermReference t_36 = new TermReference();
        TermReference u_36 = new TermReference();
        TermReference v_36 = new TermReference();
        TermReference l_32 = new TermReference();
        TermReference w_36 = new TermReference();
        TermReference x_36 = new TermReference();
        TermReference y_36 = new TermReference();
        TermReference z_36 = new TermReference();
        TermReference m_32 = new TermReference();
        TermReference a_37 = new TermReference();
        TermReference b_37 = new TermReference();
        TermReference c_37 = new TermReference();
        TermReference d_37 = new TermReference();
        TermReference n_32 = new TermReference();
        TermReference e_37 = new TermReference();
        TermReference f_37 = new TermReference();
        TermReference g_37 = new TermReference();
        TermReference h_37 = new TermReference();
        TermReference o_32 = new TermReference();
        TermReference i_37 = new TermReference();
        TermReference j_37 = new TermReference();
        TermReference k_37 = new TermReference();
        TermReference l_37 = new TermReference();
        TermReference p_32 = new TermReference();
        TermReference m_37 = new TermReference();
        TermReference n_37 = new TermReference();
        TermReference o_37 = new TermReference();
        TermReference p_37 = new TermReference();
        TermReference q_32 = new TermReference();
        TermReference q_37 = new TermReference();
        TermReference r_37 = new TermReference();
        TermReference s_37 = new TermReference();
        TermReference t_37 = new TermReference();
        TermReference r_32 = new TermReference();
        TermReference u_37 = new TermReference();
        TermReference v_37 = new TermReference();
        if(k_31.value == null)
          k_31.value = term;
        else
          if(k_31.value != term && !k_31.value.match(term))
            break Fail764;
        l_31 = term;
        y_32 = term;
        w_32 = Simplify.const62;
        term = y_32;
        z_32 = y_32;
        if(k_31.value == null)
          break Fail764;
        term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consGt_2, new IStrategoTerm[]{k_31.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
        term = dr_undefine_rule_0_2.instance.invoke(context, z_32, w_32, term);
        if(term == null)
          break Fail764;
        term = l_31;
        m_31 = l_31;
        c_33 = term;
        a_33 = Simplify.const62;
        term = c_33;
        d_33 = c_33;
        if(k_31.value == null)
          break Fail764;
        term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consLt_2, new IStrategoTerm[]{k_31.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
        term = dr_undefine_rule_0_2.instance.invoke(context, d_33, a_33, term);
        if(term == null)
          break Fail764;
        term = m_31;
        n_31 = m_31;
        g_33 = term;
        e_33 = Simplify.const62;
        term = g_33;
        h_33 = g_33;
        if(k_31.value == null)
          break Fail764;
        term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consGeq_2, new IStrategoTerm[]{k_31.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
        term = dr_undefine_rule_0_2.instance.invoke(context, h_33, e_33, term);
        if(term == null)
          break Fail764;
        term = n_31;
        o_31 = n_31;
        k_33 = term;
        i_33 = Simplify.const62;
        term = k_33;
        l_33 = k_33;
        if(k_31.value == null)
          break Fail764;
        term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consLeq_2, new IStrategoTerm[]{k_31.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
        term = dr_undefine_rule_0_2.instance.invoke(context, l_33, i_33, term);
        if(term == null)
          break Fail764;
        term = o_31;
        p_31 = o_31;
        o_33 = term;
        m_33 = Simplify.const62;
        term = o_33;
        p_33 = o_33;
        if(k_31.value == null)
          break Fail764;
        term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consEqu_2, new IStrategoTerm[]{k_31.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
        term = dr_undefine_rule_0_2.instance.invoke(context, p_33, m_33, term);
        if(term == null)
          break Fail764;
        term = p_31;
        q_31 = p_31;
        s_33 = term;
        q_33 = Simplify.const62;
        term = s_33;
        t_33 = s_33;
        if(k_31.value == null)
          break Fail764;
        term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consNeq_2, new IStrategoTerm[]{k_31.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
        term = dr_undefine_rule_0_2.instance.invoke(context, t_33, q_33, term);
        if(term == null)
          break Fail764;
        term = q_31;
        r_31 = q_31;
        w_33 = term;
        u_33 = Simplify.const55;
        term = w_33;
        x_33 = w_33;
        if(k_31.value == null)
          break Fail764;
        term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consGt_2, new IStrategoTerm[]{k_31.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
        term = dr_undefine_rule_0_2.instance.invoke(context, x_33, u_33, term);
        if(term == null)
          break Fail764;
        term = r_31;
        s_31 = r_31;
        a_34 = term;
        y_33 = Simplify.const55;
        term = a_34;
        b_34 = a_34;
        if(k_31.value == null)
          break Fail764;
        term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consLt_2, new IStrategoTerm[]{k_31.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
        term = dr_undefine_rule_0_2.instance.invoke(context, b_34, y_33, term);
        if(term == null)
          break Fail764;
        term = s_31;
        t_31 = s_31;
        e_34 = term;
        c_34 = Simplify.const55;
        term = e_34;
        f_34 = e_34;
        if(k_31.value == null)
          break Fail764;
        term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consGeq_2, new IStrategoTerm[]{k_31.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
        term = dr_undefine_rule_0_2.instance.invoke(context, f_34, c_34, term);
        if(term == null)
          break Fail764;
        term = t_31;
        u_31 = t_31;
        i_34 = term;
        g_34 = Simplify.const55;
        term = i_34;
        j_34 = i_34;
        if(k_31.value == null)
          break Fail764;
        term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consLeq_2, new IStrategoTerm[]{k_31.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
        term = dr_undefine_rule_0_2.instance.invoke(context, j_34, g_34, term);
        if(term == null)
          break Fail764;
        term = u_31;
        if(v_31.value == null)
          v_31.value = term;
        else
          if(v_31.value != term && !v_31.value.match(term))
            break Fail764;
        m_34 = term;
        term = Simplify.const55;
        if(k_34.value == null)
          k_34.value = term;
        else
          if(k_34.value != term && !k_34.value.match(term))
            break Fail764;
        term = m_34;
        n_34 = m_34;
        if(k_31.value == null)
          break Fail764;
        term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consEqu_2, new IStrategoTerm[]{k_31.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
        if(l_34.value == null)
          l_34.value = term;
        else
          if(l_34.value != term && !l_34.value.match(term))
            break Fail764;
        term = n_34;
        undefine_assertions_0_0_fragment_0 undefine_assertions_0_0_fragment_00 = new undefine_assertions_0_0_fragment_0();
        undefine_assertions_0_0_fragment_00.k_34 = k_34;
        undefine_assertions_0_0_fragment_00.l_34 = l_34;
        undefine_assertions_0_0_fragment_00.v_31 = v_31;
        undefine_assertions_0_0_fragment_00.q_34 = q_34;
        undefine_assertions_0_0_fragment_00.r_34 = r_34;
        undefine_assertions_0_0_fragment_00.o_34 = o_34;
        undefine_assertions_0_0_fragment_00.p_34 = p_34;
        undefine_assertions_0_0_fragment_00.w_31 = w_31;
        undefine_assertions_0_0_fragment_00.u_34 = u_34;
        undefine_assertions_0_0_fragment_00.v_34 = v_34;
        undefine_assertions_0_0_fragment_00.s_34 = s_34;
        undefine_assertions_0_0_fragment_00.t_34 = t_34;
        undefine_assertions_0_0_fragment_00.x_31 = x_31;
        undefine_assertions_0_0_fragment_00.y_34 = y_34;
        undefine_assertions_0_0_fragment_00.z_34 = z_34;
        undefine_assertions_0_0_fragment_00.w_34 = w_34;
        undefine_assertions_0_0_fragment_00.x_34 = x_34;
        undefine_assertions_0_0_fragment_00.y_31 = y_31;
        undefine_assertions_0_0_fragment_00.c_35 = c_35;
        undefine_assertions_0_0_fragment_00.d_35 = d_35;
        undefine_assertions_0_0_fragment_00.a_35 = a_35;
        undefine_assertions_0_0_fragment_00.b_35 = b_35;
        undefine_assertions_0_0_fragment_00.z_31 = z_31;
        undefine_assertions_0_0_fragment_00.g_35 = g_35;
        undefine_assertions_0_0_fragment_00.h_35 = h_35;
        undefine_assertions_0_0_fragment_00.e_35 = e_35;
        undefine_assertions_0_0_fragment_00.f_35 = f_35;
        undefine_assertions_0_0_fragment_00.a_32 = a_32;
        undefine_assertions_0_0_fragment_00.k_35 = k_35;
        undefine_assertions_0_0_fragment_00.l_35 = l_35;
        undefine_assertions_0_0_fragment_00.i_35 = i_35;
        undefine_assertions_0_0_fragment_00.j_35 = j_35;
        undefine_assertions_0_0_fragment_00.b_32 = b_32;
        undefine_assertions_0_0_fragment_00.o_35 = o_35;
        undefine_assertions_0_0_fragment_00.p_35 = p_35;
        undefine_assertions_0_0_fragment_00.m_35 = m_35;
        undefine_assertions_0_0_fragment_00.n_35 = n_35;
        undefine_assertions_0_0_fragment_00.c_32 = c_32;
        undefine_assertions_0_0_fragment_00.s_35 = s_35;
        undefine_assertions_0_0_fragment_00.t_35 = t_35;
        undefine_assertions_0_0_fragment_00.q_35 = q_35;
        undefine_assertions_0_0_fragment_00.r_35 = r_35;
        undefine_assertions_0_0_fragment_00.d_32 = d_32;
        undefine_assertions_0_0_fragment_00.w_35 = w_35;
        undefine_assertions_0_0_fragment_00.x_35 = x_35;
        undefine_assertions_0_0_fragment_00.u_35 = u_35;
        undefine_assertions_0_0_fragment_00.v_35 = v_35;
        undefine_assertions_0_0_fragment_00.e_32 = e_32;
        undefine_assertions_0_0_fragment_00.a_36 = a_36;
        undefine_assertions_0_0_fragment_00.b_36 = b_36;
        undefine_assertions_0_0_fragment_00.y_35 = y_35;
        undefine_assertions_0_0_fragment_00.z_35 = z_35;
        undefine_assertions_0_0_fragment_00.f_32 = f_32;
        undefine_assertions_0_0_fragment_00.e_36 = e_36;
        undefine_assertions_0_0_fragment_00.f_36 = f_36;
        undefine_assertions_0_0_fragment_00.c_36 = c_36;
        undefine_assertions_0_0_fragment_00.d_36 = d_36;
        undefine_assertions_0_0_fragment_00.g_32 = g_32;
        undefine_assertions_0_0_fragment_00.i_36 = i_36;
        undefine_assertions_0_0_fragment_00.j_36 = j_36;
        undefine_assertions_0_0_fragment_00.g_36 = g_36;
        undefine_assertions_0_0_fragment_00.h_36 = h_36;
        undefine_assertions_0_0_fragment_00.h_32 = h_32;
        undefine_assertions_0_0_fragment_00.m_36 = m_36;
        undefine_assertions_0_0_fragment_00.n_36 = n_36;
        undefine_assertions_0_0_fragment_00.k_36 = k_36;
        undefine_assertions_0_0_fragment_00.l_36 = l_36;
        undefine_assertions_0_0_fragment_00.i_32 = i_32;
        undefine_assertions_0_0_fragment_00.q_36 = q_36;
        undefine_assertions_0_0_fragment_00.r_36 = r_36;
        undefine_assertions_0_0_fragment_00.o_36 = o_36;
        undefine_assertions_0_0_fragment_00.p_36 = p_36;
        undefine_assertions_0_0_fragment_00.j_32 = j_32;
        undefine_assertions_0_0_fragment_00.u_36 = u_36;
        undefine_assertions_0_0_fragment_00.v_36 = v_36;
        undefine_assertions_0_0_fragment_00.s_36 = s_36;
        undefine_assertions_0_0_fragment_00.t_36 = t_36;
        undefine_assertions_0_0_fragment_00.k_32 = k_32;
        undefine_assertions_0_0_fragment_00.y_36 = y_36;
        undefine_assertions_0_0_fragment_00.z_36 = z_36;
        undefine_assertions_0_0_fragment_00.w_36 = w_36;
        undefine_assertions_0_0_fragment_00.x_36 = x_36;
        undefine_assertions_0_0_fragment_00.l_32 = l_32;
        undefine_assertions_0_0_fragment_00.c_37 = c_37;
        undefine_assertions_0_0_fragment_00.d_37 = d_37;
        undefine_assertions_0_0_fragment_00.a_37 = a_37;
        undefine_assertions_0_0_fragment_00.b_37 = b_37;
        undefine_assertions_0_0_fragment_00.m_32 = m_32;
        undefine_assertions_0_0_fragment_00.g_37 = g_37;
        undefine_assertions_0_0_fragment_00.h_37 = h_37;
        undefine_assertions_0_0_fragment_00.e_37 = e_37;
        undefine_assertions_0_0_fragment_00.f_37 = f_37;
        undefine_assertions_0_0_fragment_00.n_32 = n_32;
        undefine_assertions_0_0_fragment_00.k_37 = k_37;
        undefine_assertions_0_0_fragment_00.l_37 = l_37;
        undefine_assertions_0_0_fragment_00.i_37 = i_37;
        undefine_assertions_0_0_fragment_00.j_37 = j_37;
        undefine_assertions_0_0_fragment_00.o_32 = o_32;
        undefine_assertions_0_0_fragment_00.o_37 = o_37;
        undefine_assertions_0_0_fragment_00.p_37 = p_37;
        undefine_assertions_0_0_fragment_00.m_37 = m_37;
        undefine_assertions_0_0_fragment_00.n_37 = n_37;
        undefine_assertions_0_0_fragment_00.p_32 = p_32;
        undefine_assertions_0_0_fragment_00.s_37 = s_37;
        undefine_assertions_0_0_fragment_00.t_37 = t_37;
        undefine_assertions_0_0_fragment_00.q_37 = q_37;
        undefine_assertions_0_0_fragment_00.r_37 = r_37;
        undefine_assertions_0_0_fragment_00.q_32 = q_32;
        undefine_assertions_0_0_fragment_00.v_37 = v_37;
        undefine_assertions_0_0_fragment_00.u_37 = u_37;
        undefine_assertions_0_0_fragment_00.k_31 = k_31;
        undefine_assertions_0_0_fragment_00.r_32 = r_32;
        term = undefine_assertions_0_0_fragment_00.invoke(context, term);
        if(term == null)
          break Fail764;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class undefine_assertions_0_0_fragment_0 extends Strategy 
  { 
    TermReference k_34;

    TermReference l_34;

    TermReference v_31;

    TermReference q_34;

    TermReference r_34;

    TermReference o_34;

    TermReference p_34;

    TermReference w_31;

    TermReference u_34;

    TermReference v_34;

    TermReference s_34;

    TermReference t_34;

    TermReference x_31;

    TermReference y_34;

    TermReference z_34;

    TermReference w_34;

    TermReference x_34;

    TermReference y_31;

    TermReference c_35;

    TermReference d_35;

    TermReference a_35;

    TermReference b_35;

    TermReference z_31;

    TermReference g_35;

    TermReference h_35;

    TermReference e_35;

    TermReference f_35;

    TermReference a_32;

    TermReference k_35;

    TermReference l_35;

    TermReference i_35;

    TermReference j_35;

    TermReference b_32;

    TermReference o_35;

    TermReference p_35;

    TermReference m_35;

    TermReference n_35;

    TermReference c_32;

    TermReference s_35;

    TermReference t_35;

    TermReference q_35;

    TermReference r_35;

    TermReference d_32;

    TermReference w_35;

    TermReference x_35;

    TermReference u_35;

    TermReference v_35;

    TermReference e_32;

    TermReference a_36;

    TermReference b_36;

    TermReference y_35;

    TermReference z_35;

    TermReference f_32;

    TermReference e_36;

    TermReference f_36;

    TermReference c_36;

    TermReference d_36;

    TermReference g_32;

    TermReference i_36;

    TermReference j_36;

    TermReference g_36;

    TermReference h_36;

    TermReference h_32;

    TermReference m_36;

    TermReference n_36;

    TermReference k_36;

    TermReference l_36;

    TermReference i_32;

    TermReference q_36;

    TermReference r_36;

    TermReference o_36;

    TermReference p_36;

    TermReference j_32;

    TermReference u_36;

    TermReference v_36;

    TermReference s_36;

    TermReference t_36;

    TermReference k_32;

    TermReference y_36;

    TermReference z_36;

    TermReference w_36;

    TermReference x_36;

    TermReference l_32;

    TermReference c_37;

    TermReference d_37;

    TermReference a_37;

    TermReference b_37;

    TermReference m_32;

    TermReference g_37;

    TermReference h_37;

    TermReference e_37;

    TermReference f_37;

    TermReference n_32;

    TermReference k_37;

    TermReference l_37;

    TermReference i_37;

    TermReference j_37;

    TermReference o_32;

    TermReference o_37;

    TermReference p_37;

    TermReference m_37;

    TermReference n_37;

    TermReference p_32;

    TermReference s_37;

    TermReference t_37;

    TermReference q_37;

    TermReference r_37;

    TermReference q_32;

    TermReference v_37;

    TermReference u_37;

    TermReference k_31;

    TermReference r_32;

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      ITermFactory termFactory = context.getFactory();
      Fail765:
      { 
        term = dr_undefine_rule_0_2.instance.invoke(context, term, k_34.value, l_34.value);
        if(term == null)
          break Fail765;
        if(v_31.value == null)
          break Fail765;
        term = v_31.value;
        if(w_31.value == null)
          w_31.value = term;
        else
          if(w_31.value != term && !w_31.value.match(term))
            break Fail765;
        if(q_34.value == null)
          q_34.value = term;
        else
          if(q_34.value != term && !q_34.value.match(term))
            break Fail765;
        term = Simplify.const55;
        if(o_34.value == null)
          o_34.value = term;
        else
          if(o_34.value != term && !o_34.value.match(term))
            break Fail765;
        if(q_34.value == null)
          break Fail765;
        term = q_34.value;
        if(r_34.value == null)
          r_34.value = term;
        else
          if(r_34.value != term && !r_34.value.match(term))
            break Fail765;
        if(k_31.value == null)
          break Fail765;
        term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consNeq_2, new IStrategoTerm[]{k_31.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
        if(p_34.value == null)
          p_34.value = term;
        else
          if(p_34.value != term && !p_34.value.match(term))
            break Fail765;
        if(r_34.value == null)
          break Fail765;
        term = dr_undefine_rule_0_2.instance.invoke(context, r_34.value, o_34.value, p_34.value);
        if(term == null)
          break Fail765;
        if(w_31.value == null)
          break Fail765;
        term = w_31.value;
        if(x_31.value == null)
          x_31.value = term;
        else
          if(x_31.value != term && !x_31.value.match(term))
            break Fail765;
        if(u_34.value == null)
          u_34.value = term;
        else
          if(u_34.value != term && !u_34.value.match(term))
            break Fail765;
        term = Simplify.const57;
        if(s_34.value == null)
          s_34.value = term;
        else
          if(s_34.value != term && !s_34.value.match(term))
            break Fail765;
        if(u_34.value == null)
          break Fail765;
        term = u_34.value;
        if(v_34.value == null)
          v_34.value = term;
        else
          if(v_34.value != term && !v_34.value.match(term))
            break Fail765;
        if(k_31.value == null)
          break Fail765;
        term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consGt_2, new IStrategoTerm[]{k_31.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
        if(t_34.value == null)
          t_34.value = term;
        else
          if(t_34.value != term && !t_34.value.match(term))
            break Fail765;
        if(v_34.value == null)
          break Fail765;
        term = dr_undefine_rule_0_2.instance.invoke(context, v_34.value, s_34.value, t_34.value);
        if(term == null)
          break Fail765;
        if(x_31.value == null)
          break Fail765;
        term = x_31.value;
        if(y_31.value == null)
          y_31.value = term;
        else
          if(y_31.value != term && !y_31.value.match(term))
            break Fail765;
        if(y_34.value == null)
          y_34.value = term;
        else
          if(y_34.value != term && !y_34.value.match(term))
            break Fail765;
        term = Simplify.const57;
        if(w_34.value == null)
          w_34.value = term;
        else
          if(w_34.value != term && !w_34.value.match(term))
            break Fail765;
        if(y_34.value == null)
          break Fail765;
        term = y_34.value;
        if(z_34.value == null)
          z_34.value = term;
        else
          if(z_34.value != term && !z_34.value.match(term))
            break Fail765;
        if(k_31.value == null)
          break Fail765;
        term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consLt_2, new IStrategoTerm[]{k_31.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
        if(x_34.value == null)
          x_34.value = term;
        else
          if(x_34.value != term && !x_34.value.match(term))
            break Fail765;
        if(z_34.value == null)
          break Fail765;
        term = dr_undefine_rule_0_2.instance.invoke(context, z_34.value, w_34.value, x_34.value);
        if(term == null)
          break Fail765;
        if(y_31.value == null)
          break Fail765;
        term = y_31.value;
        if(z_31.value == null)
          z_31.value = term;
        else
          if(z_31.value != term && !z_31.value.match(term))
            break Fail765;
        if(c_35.value == null)
          c_35.value = term;
        else
          if(c_35.value != term && !c_35.value.match(term))
            break Fail765;
        term = Simplify.const57;
        if(a_35.value == null)
          a_35.value = term;
        else
          if(a_35.value != term && !a_35.value.match(term))
            break Fail765;
        if(c_35.value == null)
          break Fail765;
        term = c_35.value;
        if(d_35.value == null)
          d_35.value = term;
        else
          if(d_35.value != term && !d_35.value.match(term))
            break Fail765;
        if(k_31.value == null)
          break Fail765;
        term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consGeq_2, new IStrategoTerm[]{k_31.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
        if(b_35.value == null)
          b_35.value = term;
        else
          if(b_35.value != term && !b_35.value.match(term))
            break Fail765;
        if(d_35.value == null)
          break Fail765;
        term = dr_undefine_rule_0_2.instance.invoke(context, d_35.value, a_35.value, b_35.value);
        if(term == null)
          break Fail765;
        if(z_31.value == null)
          break Fail765;
        term = z_31.value;
        if(a_32.value == null)
          a_32.value = term;
        else
          if(a_32.value != term && !a_32.value.match(term))
            break Fail765;
        if(g_35.value == null)
          g_35.value = term;
        else
          if(g_35.value != term && !g_35.value.match(term))
            break Fail765;
        term = Simplify.const57;
        if(e_35.value == null)
          e_35.value = term;
        else
          if(e_35.value != term && !e_35.value.match(term))
            break Fail765;
        if(g_35.value == null)
          break Fail765;
        term = g_35.value;
        if(h_35.value == null)
          h_35.value = term;
        else
          if(h_35.value != term && !h_35.value.match(term))
            break Fail765;
        if(k_31.value == null)
          break Fail765;
        term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consLeq_2, new IStrategoTerm[]{k_31.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
        if(f_35.value == null)
          f_35.value = term;
        else
          if(f_35.value != term && !f_35.value.match(term))
            break Fail765;
        if(h_35.value == null)
          break Fail765;
        term = dr_undefine_rule_0_2.instance.invoke(context, h_35.value, e_35.value, f_35.value);
        if(term == null)
          break Fail765;
        if(a_32.value == null)
          break Fail765;
        term = a_32.value;
        if(b_32.value == null)
          b_32.value = term;
        else
          if(b_32.value != term && !b_32.value.match(term))
            break Fail765;
        if(k_35.value == null)
          k_35.value = term;
        else
          if(k_35.value != term && !k_35.value.match(term))
            break Fail765;
        term = Simplify.const57;
        if(i_35.value == null)
          i_35.value = term;
        else
          if(i_35.value != term && !i_35.value.match(term))
            break Fail765;
        if(k_35.value == null)
          break Fail765;
        term = k_35.value;
        if(l_35.value == null)
          l_35.value = term;
        else
          if(l_35.value != term && !l_35.value.match(term))
            break Fail765;
        if(k_31.value == null)
          break Fail765;
        term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consEqu_2, new IStrategoTerm[]{k_31.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
        if(j_35.value == null)
          j_35.value = term;
        else
          if(j_35.value != term && !j_35.value.match(term))
            break Fail765;
        if(l_35.value == null)
          break Fail765;
        term = dr_undefine_rule_0_2.instance.invoke(context, l_35.value, i_35.value, j_35.value);
        if(term == null)
          break Fail765;
        if(b_32.value == null)
          break Fail765;
        term = b_32.value;
        if(c_32.value == null)
          c_32.value = term;
        else
          if(c_32.value != term && !c_32.value.match(term))
            break Fail765;
        if(o_35.value == null)
          o_35.value = term;
        else
          if(o_35.value != term && !o_35.value.match(term))
            break Fail765;
        term = Simplify.const57;
        if(m_35.value == null)
          m_35.value = term;
        else
          if(m_35.value != term && !m_35.value.match(term))
            break Fail765;
        if(o_35.value == null)
          break Fail765;
        term = o_35.value;
        if(p_35.value == null)
          p_35.value = term;
        else
          if(p_35.value != term && !p_35.value.match(term))
            break Fail765;
        if(k_31.value == null)
          break Fail765;
        term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consNeq_2, new IStrategoTerm[]{k_31.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
        if(n_35.value == null)
          n_35.value = term;
        else
          if(n_35.value != term && !n_35.value.match(term))
            break Fail765;
        if(p_35.value == null)
          break Fail765;
        term = dr_undefine_rule_0_2.instance.invoke(context, p_35.value, m_35.value, n_35.value);
        if(term == null)
          break Fail765;
        if(c_32.value == null)
          break Fail765;
        term = c_32.value;
        if(d_32.value == null)
          d_32.value = term;
        else
          if(d_32.value != term && !d_32.value.match(term))
            break Fail765;
        if(s_35.value == null)
          s_35.value = term;
        else
          if(s_35.value != term && !s_35.value.match(term))
            break Fail765;
        term = Simplify.const58;
        if(q_35.value == null)
          q_35.value = term;
        else
          if(q_35.value != term && !q_35.value.match(term))
            break Fail765;
        if(s_35.value == null)
          break Fail765;
        term = s_35.value;
        if(t_35.value == null)
          t_35.value = term;
        else
          if(t_35.value != term && !t_35.value.match(term))
            break Fail765;
        if(k_31.value == null)
          break Fail765;
        term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consGt_2, new IStrategoTerm[]{k_31.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
        if(r_35.value == null)
          r_35.value = term;
        else
          if(r_35.value != term && !r_35.value.match(term))
            break Fail765;
        if(t_35.value == null)
          break Fail765;
        term = dr_undefine_rule_0_2.instance.invoke(context, t_35.value, q_35.value, r_35.value);
        if(term == null)
          break Fail765;
        if(d_32.value == null)
          break Fail765;
        term = d_32.value;
        if(e_32.value == null)
          e_32.value = term;
        else
          if(e_32.value != term && !e_32.value.match(term))
            break Fail765;
        if(w_35.value == null)
          w_35.value = term;
        else
          if(w_35.value != term && !w_35.value.match(term))
            break Fail765;
        term = Simplify.const58;
        if(u_35.value == null)
          u_35.value = term;
        else
          if(u_35.value != term && !u_35.value.match(term))
            break Fail765;
        if(w_35.value == null)
          break Fail765;
        term = w_35.value;
        if(x_35.value == null)
          x_35.value = term;
        else
          if(x_35.value != term && !x_35.value.match(term))
            break Fail765;
        if(k_31.value == null)
          break Fail765;
        term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consLt_2, new IStrategoTerm[]{k_31.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
        if(v_35.value == null)
          v_35.value = term;
        else
          if(v_35.value != term && !v_35.value.match(term))
            break Fail765;
        if(x_35.value == null)
          break Fail765;
        term = dr_undefine_rule_0_2.instance.invoke(context, x_35.value, u_35.value, v_35.value);
        if(term == null)
          break Fail765;
        if(e_32.value == null)
          break Fail765;
        term = e_32.value;
        if(f_32.value == null)
          f_32.value = term;
        else
          if(f_32.value != term && !f_32.value.match(term))
            break Fail765;
        if(a_36.value == null)
          a_36.value = term;
        else
          if(a_36.value != term && !a_36.value.match(term))
            break Fail765;
        term = Simplify.const58;
        if(y_35.value == null)
          y_35.value = term;
        else
          if(y_35.value != term && !y_35.value.match(term))
            break Fail765;
        if(a_36.value == null)
          break Fail765;
        term = a_36.value;
        if(b_36.value == null)
          b_36.value = term;
        else
          if(b_36.value != term && !b_36.value.match(term))
            break Fail765;
        if(k_31.value == null)
          break Fail765;
        term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consGeq_2, new IStrategoTerm[]{k_31.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
        if(z_35.value == null)
          z_35.value = term;
        else
          if(z_35.value != term && !z_35.value.match(term))
            break Fail765;
        if(b_36.value == null)
          break Fail765;
        term = dr_undefine_rule_0_2.instance.invoke(context, b_36.value, y_35.value, z_35.value);
        if(term == null)
          break Fail765;
        if(f_32.value == null)
          break Fail765;
        term = f_32.value;
        if(g_32.value == null)
          g_32.value = term;
        else
          if(g_32.value != term && !g_32.value.match(term))
            break Fail765;
        if(e_36.value == null)
          e_36.value = term;
        else
          if(e_36.value != term && !e_36.value.match(term))
            break Fail765;
        term = Simplify.const58;
        if(c_36.value == null)
          c_36.value = term;
        else
          if(c_36.value != term && !c_36.value.match(term))
            break Fail765;
        if(e_36.value == null)
          break Fail765;
        term = e_36.value;
        if(f_36.value == null)
          f_36.value = term;
        else
          if(f_36.value != term && !f_36.value.match(term))
            break Fail765;
        if(k_31.value == null)
          break Fail765;
        term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consLeq_2, new IStrategoTerm[]{k_31.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
        if(d_36.value == null)
          d_36.value = term;
        else
          if(d_36.value != term && !d_36.value.match(term))
            break Fail765;
        if(f_36.value == null)
          break Fail765;
        term = dr_undefine_rule_0_2.instance.invoke(context, f_36.value, c_36.value, d_36.value);
        if(term == null)
          break Fail765;
        if(g_32.value == null)
          break Fail765;
        term = g_32.value;
        if(h_32.value == null)
          h_32.value = term;
        else
          if(h_32.value != term && !h_32.value.match(term))
            break Fail765;
        if(i_36.value == null)
          i_36.value = term;
        else
          if(i_36.value != term && !i_36.value.match(term))
            break Fail765;
        term = Simplify.const58;
        if(g_36.value == null)
          g_36.value = term;
        else
          if(g_36.value != term && !g_36.value.match(term))
            break Fail765;
        if(i_36.value == null)
          break Fail765;
        term = i_36.value;
        if(j_36.value == null)
          j_36.value = term;
        else
          if(j_36.value != term && !j_36.value.match(term))
            break Fail765;
        if(k_31.value == null)
          break Fail765;
        term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consEqu_2, new IStrategoTerm[]{k_31.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
        if(h_36.value == null)
          h_36.value = term;
        else
          if(h_36.value != term && !h_36.value.match(term))
            break Fail765;
        if(j_36.value == null)
          break Fail765;
        term = dr_undefine_rule_0_2.instance.invoke(context, j_36.value, g_36.value, h_36.value);
        if(term == null)
          break Fail765;
        if(h_32.value == null)
          break Fail765;
        term = h_32.value;
        if(i_32.value == null)
          i_32.value = term;
        else
          if(i_32.value != term && !i_32.value.match(term))
            break Fail765;
        if(m_36.value == null)
          m_36.value = term;
        else
          if(m_36.value != term && !m_36.value.match(term))
            break Fail765;
        term = Simplify.const58;
        if(k_36.value == null)
          k_36.value = term;
        else
          if(k_36.value != term && !k_36.value.match(term))
            break Fail765;
        if(m_36.value == null)
          break Fail765;
        term = m_36.value;
        if(n_36.value == null)
          n_36.value = term;
        else
          if(n_36.value != term && !n_36.value.match(term))
            break Fail765;
        if(k_31.value == null)
          break Fail765;
        term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consNeq_2, new IStrategoTerm[]{k_31.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
        if(l_36.value == null)
          l_36.value = term;
        else
          if(l_36.value != term && !l_36.value.match(term))
            break Fail765;
        if(n_36.value == null)
          break Fail765;
        term = dr_undefine_rule_0_2.instance.invoke(context, n_36.value, k_36.value, l_36.value);
        if(term == null)
          break Fail765;
        if(i_32.value == null)
          break Fail765;
        term = i_32.value;
        if(j_32.value == null)
          j_32.value = term;
        else
          if(j_32.value != term && !j_32.value.match(term))
            break Fail765;
        if(q_36.value == null)
          q_36.value = term;
        else
          if(q_36.value != term && !q_36.value.match(term))
            break Fail765;
        term = Simplify.const59;
        if(o_36.value == null)
          o_36.value = term;
        else
          if(o_36.value != term && !o_36.value.match(term))
            break Fail765;
        if(q_36.value == null)
          break Fail765;
        term = q_36.value;
        if(r_36.value == null)
          r_36.value = term;
        else
          if(r_36.value != term && !r_36.value.match(term))
            break Fail765;
        if(k_31.value == null)
          break Fail765;
        term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consEqu_2, new IStrategoTerm[]{k_31.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
        if(p_36.value == null)
          p_36.value = term;
        else
          if(p_36.value != term && !p_36.value.match(term))
            break Fail765;
        if(r_36.value == null)
          break Fail765;
        term = dr_undefine_rule_0_2.instance.invoke(context, r_36.value, o_36.value, p_36.value);
        if(term == null)
          break Fail765;
        if(j_32.value == null)
          break Fail765;
        term = j_32.value;
        if(k_32.value == null)
          k_32.value = term;
        else
          if(k_32.value != term && !k_32.value.match(term))
            break Fail765;
        if(u_36.value == null)
          u_36.value = term;
        else
          if(u_36.value != term && !u_36.value.match(term))
            break Fail765;
        term = Simplify.const59;
        if(s_36.value == null)
          s_36.value = term;
        else
          if(s_36.value != term && !s_36.value.match(term))
            break Fail765;
        if(u_36.value == null)
          break Fail765;
        term = u_36.value;
        if(v_36.value == null)
          v_36.value = term;
        else
          if(v_36.value != term && !v_36.value.match(term))
            break Fail765;
        if(k_31.value == null)
          break Fail765;
        term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consNeq_2, new IStrategoTerm[]{k_31.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
        if(t_36.value == null)
          t_36.value = term;
        else
          if(t_36.value != term && !t_36.value.match(term))
            break Fail765;
        if(v_36.value == null)
          break Fail765;
        term = dr_undefine_rule_0_2.instance.invoke(context, v_36.value, s_36.value, t_36.value);
        if(term == null)
          break Fail765;
        if(k_32.value == null)
          break Fail765;
        term = k_32.value;
        if(l_32.value == null)
          l_32.value = term;
        else
          if(l_32.value != term && !l_32.value.match(term))
            break Fail765;
        if(y_36.value == null)
          y_36.value = term;
        else
          if(y_36.value != term && !y_36.value.match(term))
            break Fail765;
        term = Simplify.const60;
        if(w_36.value == null)
          w_36.value = term;
        else
          if(w_36.value != term && !w_36.value.match(term))
            break Fail765;
        if(y_36.value == null)
          break Fail765;
        term = y_36.value;
        if(z_36.value == null)
          z_36.value = term;
        else
          if(z_36.value != term && !z_36.value.match(term))
            break Fail765;
        if(k_31.value == null)
          break Fail765;
        term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consGt_2, new IStrategoTerm[]{k_31.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
        if(x_36.value == null)
          x_36.value = term;
        else
          if(x_36.value != term && !x_36.value.match(term))
            break Fail765;
        if(z_36.value == null)
          break Fail765;
        term = dr_undefine_rule_0_2.instance.invoke(context, z_36.value, w_36.value, x_36.value);
        if(term == null)
          break Fail765;
        if(l_32.value == null)
          break Fail765;
        term = l_32.value;
        if(m_32.value == null)
          m_32.value = term;
        else
          if(m_32.value != term && !m_32.value.match(term))
            break Fail765;
        if(c_37.value == null)
          c_37.value = term;
        else
          if(c_37.value != term && !c_37.value.match(term))
            break Fail765;
        term = Simplify.const60;
        if(a_37.value == null)
          a_37.value = term;
        else
          if(a_37.value != term && !a_37.value.match(term))
            break Fail765;
        if(c_37.value == null)
          break Fail765;
        term = c_37.value;
        if(d_37.value == null)
          d_37.value = term;
        else
          if(d_37.value != term && !d_37.value.match(term))
            break Fail765;
        if(k_31.value == null)
          break Fail765;
        term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consLt_2, new IStrategoTerm[]{k_31.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
        if(b_37.value == null)
          b_37.value = term;
        else
          if(b_37.value != term && !b_37.value.match(term))
            break Fail765;
        if(d_37.value == null)
          break Fail765;
        term = dr_undefine_rule_0_2.instance.invoke(context, d_37.value, a_37.value, b_37.value);
        if(term == null)
          break Fail765;
        if(m_32.value == null)
          break Fail765;
        term = m_32.value;
        if(n_32.value == null)
          n_32.value = term;
        else
          if(n_32.value != term && !n_32.value.match(term))
            break Fail765;
        if(g_37.value == null)
          g_37.value = term;
        else
          if(g_37.value != term && !g_37.value.match(term))
            break Fail765;
        term = Simplify.const60;
        if(e_37.value == null)
          e_37.value = term;
        else
          if(e_37.value != term && !e_37.value.match(term))
            break Fail765;
        if(g_37.value == null)
          break Fail765;
        term = g_37.value;
        if(h_37.value == null)
          h_37.value = term;
        else
          if(h_37.value != term && !h_37.value.match(term))
            break Fail765;
        if(k_31.value == null)
          break Fail765;
        term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consGeq_2, new IStrategoTerm[]{k_31.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
        if(f_37.value == null)
          f_37.value = term;
        else
          if(f_37.value != term && !f_37.value.match(term))
            break Fail765;
        if(h_37.value == null)
          break Fail765;
        term = dr_undefine_rule_0_2.instance.invoke(context, h_37.value, e_37.value, f_37.value);
        if(term == null)
          break Fail765;
        if(n_32.value == null)
          break Fail765;
        term = n_32.value;
        if(o_32.value == null)
          o_32.value = term;
        else
          if(o_32.value != term && !o_32.value.match(term))
            break Fail765;
        if(k_37.value == null)
          k_37.value = term;
        else
          if(k_37.value != term && !k_37.value.match(term))
            break Fail765;
        term = Simplify.const60;
        if(i_37.value == null)
          i_37.value = term;
        else
          if(i_37.value != term && !i_37.value.match(term))
            break Fail765;
        if(k_37.value == null)
          break Fail765;
        term = k_37.value;
        if(l_37.value == null)
          l_37.value = term;
        else
          if(l_37.value != term && !l_37.value.match(term))
            break Fail765;
        if(k_31.value == null)
          break Fail765;
        term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consLeq_2, new IStrategoTerm[]{k_31.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
        if(j_37.value == null)
          j_37.value = term;
        else
          if(j_37.value != term && !j_37.value.match(term))
            break Fail765;
        if(l_37.value == null)
          break Fail765;
        term = dr_undefine_rule_0_2.instance.invoke(context, l_37.value, i_37.value, j_37.value);
        if(term == null)
          break Fail765;
        if(o_32.value == null)
          break Fail765;
        term = o_32.value;
        if(p_32.value == null)
          p_32.value = term;
        else
          if(p_32.value != term && !p_32.value.match(term))
            break Fail765;
        if(o_37.value == null)
          o_37.value = term;
        else
          if(o_37.value != term && !o_37.value.match(term))
            break Fail765;
        term = Simplify.const60;
        if(m_37.value == null)
          m_37.value = term;
        else
          if(m_37.value != term && !m_37.value.match(term))
            break Fail765;
        if(o_37.value == null)
          break Fail765;
        term = o_37.value;
        if(p_37.value == null)
          p_37.value = term;
        else
          if(p_37.value != term && !p_37.value.match(term))
            break Fail765;
        if(k_31.value == null)
          break Fail765;
        term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consEqu_2, new IStrategoTerm[]{k_31.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
        if(n_37.value == null)
          n_37.value = term;
        else
          if(n_37.value != term && !n_37.value.match(term))
            break Fail765;
        if(p_37.value == null)
          break Fail765;
        term = dr_undefine_rule_0_2.instance.invoke(context, p_37.value, m_37.value, n_37.value);
        if(term == null)
          break Fail765;
        if(p_32.value == null)
          break Fail765;
        term = p_32.value;
        if(q_32.value == null)
          q_32.value = term;
        else
          if(q_32.value != term && !q_32.value.match(term))
            break Fail765;
        if(s_37.value == null)
          s_37.value = term;
        else
          if(s_37.value != term && !s_37.value.match(term))
            break Fail765;
        term = Simplify.const60;
        if(q_37.value == null)
          q_37.value = term;
        else
          if(q_37.value != term && !q_37.value.match(term))
            break Fail765;
        if(s_37.value == null)
          break Fail765;
        term = s_37.value;
        if(t_37.value == null)
          t_37.value = term;
        else
          if(t_37.value != term && !t_37.value.match(term))
            break Fail765;
        if(k_31.value == null)
          break Fail765;
        term = termFactory.annotateTerm(termFactory.makeAppl(Simplify._consNeq_2, new IStrategoTerm[]{k_31.value, Simplify.const56}), checkListAnnos(termFactory, Simplify.constCons16));
        if(r_37.value == null)
          r_37.value = term;
        else
          if(r_37.value != term && !r_37.value.match(term))
            break Fail765;
        if(t_37.value == null)
          break Fail765;
        term = dr_undefine_rule_0_2.instance.invoke(context, t_37.value, q_37.value, r_37.value);
        if(term == null)
          break Fail765;
        if(q_32.value == null)
          break Fail765;
        term = q_32.value;
        if(r_32.value == null)
          r_32.value = term;
        else
          if(r_32.value != term && !r_32.value.match(term))
            break Fail765;
        if(v_37.value == null)
          v_37.value = term;
        else
          if(v_37.value != term && !v_37.value.match(term))
            break Fail765;
        term = Simplify.const61;
        if(u_37.value == null)
          u_37.value = term;
        else
          if(u_37.value != term && !u_37.value.match(term))
            break Fail765;
        if(v_37.value == null)
          break Fail765;
        term = dr_undefine_rule_0_2.instance.invoke(context, v_37.value, u_37.value, k_31.value);
        if(term == null)
          break Fail765;
        if(r_32.value == null)
          break Fail765;
        term = r_32.value;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted112 extends Strategy 
  { 
    TermReference x_29;

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail766:
      { 
        IStrategoTerm term93 = term;
        Success528:
        { 
          Fail767:
          { 
            term = define_assertion_gt_0_0.instance.invoke(context, term);
            if(term == null)
              break Fail767;
            if(true)
              break Success528;
          }
          term = term93;
          IStrategoTerm term94 = term;
          Success529:
          { 
            Fail768:
            { 
              term = define_assertion_geq_0_0.instance.invoke(context, term);
              if(term == null)
                break Fail768;
              if(true)
                break Success529;
            }
            term = term94;
            IStrategoTerm term95 = term;
            Success530:
            { 
              Fail769:
              { 
                term = define_assertion_equ_0_0.instance.invoke(context, term);
                if(term == null)
                  break Fail769;
                if(true)
                  break Success530;
              }
              term = term95;
              IStrategoTerm term96 = term;
              Success531:
              { 
                Fail770:
                { 
                  term = define_assertion_leq_0_0.instance.invoke(context, term);
                  if(term == null)
                    break Fail770;
                  if(true)
                    break Success531;
                }
                term = term96;
                IStrategoTerm term97 = term;
                Success532:
                { 
                  Fail771:
                  { 
                    term = define_assertion_lt_0_0.instance.invoke(context, term);
                    if(term == null)
                      break Fail771;
                    if(true)
                      break Success532;
                  }
                  term = term97;
                  IStrategoTerm term98 = term;
                  Success533:
                  { 
                    Fail772:
                    { 
                      term = define_assertion_neq_0_0.instance.invoke(context, term);
                      if(term == null)
                        break Fail772;
                      if(true)
                        break Success533;
                    }
                    term = term98;
                    IStrategoTerm term99 = term;
                    Success534:
                    { 
                      Fail773:
                      { 
                        term = define_assertion_false_0_1.instance.invoke(context, term, x_29.value);
                        if(term == null)
                          break Fail773;
                        if(true)
                          break Success534;
                      }
                      term = define_assertion_true_0_1.instance.invoke(context, term99, x_29.value);
                      if(term == null)
                        break Fail766;
                    }
                  }
                }
              }
            }
          }
        }
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class v_423 extends Strategy 
  { 
    public static final v_423 instance = new v_423();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      ITermFactory termFactory = context.getFactory();
      Fail774:
      { 
        IStrategoTerm term53 = term;
        Success535:
        { 
          Fail775:
          { 
            IStrategoTerm term54 = term;
            Success536:
            { 
              Fail776:
              { 
                IStrategoTerm term55 = term;
                IStrategoConstructor cons81 = term.getTermType() == IStrategoTerm.APPL ? ((IStrategoAppl)term).getConstructor() : null;
                Success537:
                { 
                  if(cons81 == Simplify._consAdd_2)
                  { 
                    Fail777:
                    { 
                      IStrategoTerm c_421 = null;
                      IStrategoTerm d_421 = null;
                      c_421 = term.getSubterm(0);
                      IStrategoTerm arg34 = term.getSubterm(1);
                      if(arg34.getTermType() != IStrategoTerm.APPL || Simplify._consNeg_1 != ((IStrategoAppl)arg34).getConstructor())
                        break Fail777;
                      d_421 = arg34.getSubterm(0);
                      term = termFactory.makeAppl(Simplify._consSub_2, new IStrategoTerm[]{c_421, d_421});
                      if(true)
                        break Success537;
                    }
                    term = term55;
                  }
                  Success538:
                  { 
                    if(cons81 == Simplify._consMul_2)
                    { 
                      Fail778:
                      { 
                        IStrategoTerm e_421 = null;
                        IStrategoTerm f_421 = null;
                        f_421 = term.getSubterm(0);
                        IStrategoTerm arg35 = term.getSubterm(1);
                        if(arg35.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg35).getConstructor())
                          break Fail778;
                        e_421 = arg35.getSubterm(0);
                        term = f_421;
                        IStrategoTerm term57 = term;
                        Success539:
                        { 
                          Fail779:
                          { 
                            if(term.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)term).getConstructor())
                              break Fail779;
                            { 
                              if(true)
                                break Fail778;
                              if(true)
                                break Success539;
                            }
                          }
                          term = term57;
                        }
                        term = termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{e_421}), f_421});
                        term = this.invoke(context, term);
                        if(term == null)
                          break Fail778;
                        if(true)
                          break Success538;
                      }
                      term = term55;
                    }
                    Success540:
                    { 
                      if(cons81 == Simplify._consAdd_2)
                      { 
                        Fail780:
                        { 
                          IStrategoTerm h_421 = null;
                          IStrategoTerm i_421 = null;
                          IStrategoTerm j_421 = null;
                          h_421 = term.getSubterm(0);
                          IStrategoTerm arg37 = term.getSubterm(1);
                          if(arg37.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg37).getConstructor())
                            break Fail780;
                          i_421 = arg37.getSubterm(0);
                          term = termFactory.makeTuple(i_421, Simplify.const53);
                          term = lt$S_0_0.instance.invoke(context, term);
                          if(term == null)
                            break Fail780;
                          term = termFactory.makeTuple(Simplify.const53, i_421);
                          term = subt$S_0_0.instance.invoke(context, term);
                          if(term == null)
                            break Fail780;
                          j_421 = term;
                          term = u_423.instance.invoke(context, j_421, this);
                          if(term == null)
                            break Fail780;
                          term = termFactory.makeAppl(Simplify._consSub_2, new IStrategoTerm[]{h_421, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{term})});
                          if(true)
                            break Success540;
                        }
                        term = term55;
                      }
                      Success541:
                      { 
                        if(cons81 == Simplify._consGt_2)
                        { 
                          Fail781:
                          { 
                            IStrategoTerm n_421 = null;
                            IStrategoTerm o_421 = null;
                            IStrategoTerm p_421 = null;
                            IStrategoTerm arg38 = term.getSubterm(0);
                            if(arg38.getTermType() != IStrategoTerm.APPL || Simplify._consSub_2 != ((IStrategoAppl)arg38).getConstructor())
                              break Fail781;
                            n_421 = arg38.getSubterm(0);
                            o_421 = arg38.getSubterm(1);
                            p_421 = term.getSubterm(1);
                            term = termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{o_421, p_421});
                            term = this.invoke(context, term);
                            if(term == null)
                              break Fail781;
                            term = termFactory.makeAppl(Simplify._consGt_2, new IStrategoTerm[]{n_421, term});
                            term = this.invoke(context, term);
                            if(term == null)
                              break Fail781;
                            if(true)
                              break Success541;
                          }
                          term = term55;
                        }
                        Success542:
                        { 
                          if(cons81 == Simplify._consGeq_2)
                          { 
                            Fail782:
                            { 
                              IStrategoTerm s_421 = null;
                              IStrategoTerm t_421 = null;
                              IStrategoTerm u_421 = null;
                              IStrategoTerm arg39 = term.getSubterm(0);
                              if(arg39.getTermType() != IStrategoTerm.APPL || Simplify._consSub_2 != ((IStrategoAppl)arg39).getConstructor())
                                break Fail782;
                              s_421 = arg39.getSubterm(0);
                              t_421 = arg39.getSubterm(1);
                              u_421 = term.getSubterm(1);
                              term = termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{t_421, u_421});
                              term = this.invoke(context, term);
                              if(term == null)
                                break Fail782;
                              term = termFactory.makeAppl(Simplify._consGeq_2, new IStrategoTerm[]{s_421, term});
                              term = this.invoke(context, term);
                              if(term == null)
                                break Fail782;
                              if(true)
                                break Success542;
                            }
                            term = term55;
                          }
                          Success543:
                          { 
                            if(cons81 == Simplify._consEqu_2)
                            { 
                              Fail783:
                              { 
                                IStrategoTerm x_421 = null;
                                IStrategoTerm y_421 = null;
                                IStrategoTerm z_421 = null;
                                IStrategoTerm arg40 = term.getSubterm(0);
                                if(arg40.getTermType() != IStrategoTerm.APPL || Simplify._consSub_2 != ((IStrategoAppl)arg40).getConstructor())
                                  break Fail783;
                                x_421 = arg40.getSubterm(0);
                                y_421 = arg40.getSubterm(1);
                                z_421 = term.getSubterm(1);
                                term = termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{y_421, z_421});
                                term = this.invoke(context, term);
                                if(term == null)
                                  break Fail783;
                                term = termFactory.makeAppl(Simplify._consEqu_2, new IStrategoTerm[]{x_421, term});
                                term = this.invoke(context, term);
                                if(term == null)
                                  break Fail783;
                                if(true)
                                  break Success543;
                              }
                              term = term55;
                            }
                            Success544:
                            { 
                              if(cons81 == Simplify._consLt_2)
                              { 
                                Fail784:
                                { 
                                  IStrategoTerm c_422 = null;
                                  IStrategoTerm d_422 = null;
                                  IStrategoTerm e_422 = null;
                                  IStrategoTerm arg41 = term.getSubterm(0);
                                  if(arg41.getTermType() != IStrategoTerm.APPL || Simplify._consSub_2 != ((IStrategoAppl)arg41).getConstructor())
                                    break Fail784;
                                  c_422 = arg41.getSubterm(0);
                                  d_422 = arg41.getSubterm(1);
                                  e_422 = term.getSubterm(1);
                                  term = termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{d_422, e_422});
                                  term = this.invoke(context, term);
                                  if(term == null)
                                    break Fail784;
                                  term = termFactory.makeAppl(Simplify._consLt_2, new IStrategoTerm[]{c_422, term});
                                  term = this.invoke(context, term);
                                  if(term == null)
                                    break Fail784;
                                  if(true)
                                    break Success544;
                                }
                                term = term55;
                              }
                              Success545:
                              { 
                                if(cons81 == Simplify._consLeq_2)
                                { 
                                  Fail785:
                                  { 
                                    IStrategoTerm h_422 = null;
                                    IStrategoTerm i_422 = null;
                                    IStrategoTerm j_422 = null;
                                    IStrategoTerm arg42 = term.getSubterm(0);
                                    if(arg42.getTermType() != IStrategoTerm.APPL || Simplify._consSub_2 != ((IStrategoAppl)arg42).getConstructor())
                                      break Fail785;
                                    h_422 = arg42.getSubterm(0);
                                    i_422 = arg42.getSubterm(1);
                                    j_422 = term.getSubterm(1);
                                    term = termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{i_422, j_422});
                                    term = this.invoke(context, term);
                                    if(term == null)
                                      break Fail785;
                                    term = termFactory.makeAppl(Simplify._consLeq_2, new IStrategoTerm[]{h_422, term});
                                    term = this.invoke(context, term);
                                    if(term == null)
                                      break Fail785;
                                    if(true)
                                      break Success545;
                                  }
                                  term = term55;
                                }
                                if(cons81 == Simplify._consNeq_2)
                                { 
                                  IStrategoTerm m_422 = null;
                                  IStrategoTerm n_422 = null;
                                  IStrategoTerm o_422 = null;
                                  IStrategoTerm arg43 = term.getSubterm(0);
                                  if(arg43.getTermType() != IStrategoTerm.APPL || Simplify._consSub_2 != ((IStrategoAppl)arg43).getConstructor())
                                    break Fail776;
                                  m_422 = arg43.getSubterm(0);
                                  n_422 = arg43.getSubterm(1);
                                  o_422 = term.getSubterm(1);
                                  term = termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{n_422, o_422});
                                  term = this.invoke(context, term);
                                  if(term == null)
                                    break Fail776;
                                  term = termFactory.makeAppl(Simplify._consNeq_2, new IStrategoTerm[]{m_422, term});
                                  term = this.invoke(context, term);
                                  if(term == null)
                                    break Fail776;
                                }
                                else
                                { 
                                  break Fail776;
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
                if(true)
                  break Success536;
              }
              term = term54;
              IStrategoTerm term64 = term;
              Success546:
              { 
                Fail786:
                { 
                  IStrategoTerm term65 = term;
                  IStrategoConstructor cons83 = term.getTermType() == IStrategoTerm.APPL ? ((IStrategoAppl)term).getConstructor() : null;
                  Success547:
                  { 
                    if(cons83 == Simplify._consAdd_2)
                    { 
                      Fail787:
                      { 
                        IStrategoTerm r_422 = null;
                        IStrategoTerm s_422 = null;
                        IStrategoTerm t_422 = null;
                        r_422 = term.getSubterm(0);
                        IStrategoTerm arg44 = term.getSubterm(1);
                        if(arg44.getTermType() != IStrategoTerm.APPL || Simplify._consAdd_2 != ((IStrategoAppl)arg44).getConstructor())
                          break Fail787;
                        s_422 = arg44.getSubterm(0);
                        t_422 = arg44.getSubterm(1);
                        term = termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{r_422, s_422});
                        term = this.invoke(context, term);
                        if(term == null)
                          break Fail787;
                        term = termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{term, t_422});
                        term = this.invoke(context, term);
                        if(term == null)
                          break Fail787;
                        if(true)
                          break Success547;
                      }
                      term = term65;
                    }
                    Success548:
                    { 
                      if(cons83 == Simplify._consMul_2)
                      { 
                        Fail788:
                        { 
                          IStrategoTerm w_422 = null;
                          IStrategoTerm x_422 = null;
                          IStrategoTerm y_422 = null;
                          w_422 = term.getSubterm(0);
                          IStrategoTerm arg45 = term.getSubterm(1);
                          if(arg45.getTermType() != IStrategoTerm.APPL || Simplify._consMul_2 != ((IStrategoAppl)arg45).getConstructor())
                            break Fail788;
                          x_422 = arg45.getSubterm(0);
                          y_422 = arg45.getSubterm(1);
                          term = termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{w_422, x_422});
                          term = this.invoke(context, term);
                          if(term == null)
                            break Fail788;
                          term = termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{term, y_422});
                          term = this.invoke(context, term);
                          if(term == null)
                            break Fail788;
                          if(true)
                            break Success548;
                        }
                        term = term65;
                      }
                      Success549:
                      { 
                        if(cons83 == Simplify._consAnd_2)
                        { 
                          Fail789:
                          { 
                            IStrategoTerm b_423 = null;
                            IStrategoTerm c_423 = null;
                            IStrategoTerm d_423 = null;
                            b_423 = term.getSubterm(0);
                            IStrategoTerm arg46 = term.getSubterm(1);
                            if(arg46.getTermType() != IStrategoTerm.APPL || Simplify._consAnd_2 != ((IStrategoAppl)arg46).getConstructor())
                              break Fail789;
                            c_423 = arg46.getSubterm(0);
                            d_423 = arg46.getSubterm(1);
                            term = termFactory.makeAppl(Simplify._consAnd_2, new IStrategoTerm[]{b_423, c_423});
                            term = this.invoke(context, term);
                            if(term == null)
                              break Fail789;
                            term = termFactory.makeAppl(Simplify._consAnd_2, new IStrategoTerm[]{term, d_423});
                            term = this.invoke(context, term);
                            if(term == null)
                              break Fail789;
                            if(true)
                              break Success549;
                          }
                          term = term65;
                        }
                        if(cons83 == Simplify._consOr_2)
                        { 
                          IStrategoTerm g_423 = null;
                          IStrategoTerm h_423 = null;
                          IStrategoTerm i_423 = null;
                          g_423 = term.getSubterm(0);
                          IStrategoTerm arg47 = term.getSubterm(1);
                          if(arg47.getTermType() != IStrategoTerm.APPL || Simplify._consOr_2 != ((IStrategoAppl)arg47).getConstructor())
                            break Fail786;
                          h_423 = arg47.getSubterm(0);
                          i_423 = arg47.getSubterm(1);
                          term = termFactory.makeAppl(Simplify._consOr_2, new IStrategoTerm[]{g_423, h_423});
                          term = this.invoke(context, term);
                          if(term == null)
                            break Fail786;
                          term = termFactory.makeAppl(Simplify._consOr_2, new IStrategoTerm[]{term, i_423});
                          term = this.invoke(context, term);
                          if(term == null)
                            break Fail786;
                        }
                        else
                        { 
                          break Fail786;
                        }
                      }
                    }
                  }
                  if(true)
                    break Success546;
                }
                term = term64;
                IStrategoTerm term68 = term;
                Success550:
                { 
                  Fail790:
                  { 
                    IStrategoTerm term69 = term;
                    IStrategoConstructor cons84 = term.getTermType() == IStrategoTerm.APPL ? ((IStrategoAppl)term).getConstructor() : null;
                    Success551:
                    { 
                      if(cons84 == Simplify._consAdd_2)
                      { 
                        Fail791:
                        { 
                          IStrategoTerm l_423 = null;
                          l_423 = term.getSubterm(0);
                          IStrategoTerm arg48 = term.getSubterm(1);
                          if(arg48.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg48).getConstructor())
                            break Fail791;
                          IStrategoTerm arg49 = arg48.getSubterm(0);
                          if(arg49.getTermType() != IStrategoTerm.STRING || !"0".equals(((IStrategoString)arg49).stringValue()))
                            break Fail791;
                          term = l_423;
                          if(true)
                            break Success551;
                        }
                        term = term69;
                      }
                      if(cons84 == Simplify._consAdd_2)
                      { 
                        IStrategoTerm m_423 = null;
                        IStrategoTerm arg50 = term.getSubterm(0);
                        if(arg50.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg50).getConstructor())
                          break Fail790;
                        IStrategoTerm arg51 = arg50.getSubterm(0);
                        if(arg51.getTermType() != IStrategoTerm.STRING || !"0".equals(((IStrategoString)arg51).stringValue()))
                          break Fail790;
                        m_423 = term.getSubterm(1);
                        term = m_423;
                      }
                      else
                      { 
                        break Fail790;
                      }
                    }
                    if(true)
                      break Success550;
                  }
                  term = term68;
                  IStrategoTerm term70 = term;
                  IStrategoConstructor cons85 = term.getTermType() == IStrategoTerm.APPL ? ((IStrategoAppl)term).getConstructor() : null;
                  Success552:
                  { 
                    if(cons85 == Simplify._consNeg_1)
                    { 
                      Fail792:
                      { 
                        IStrategoTerm n_423 = null;
                        IStrategoTerm o_423 = null;
                        IStrategoTerm arg52 = term.getSubterm(0);
                        if(arg52.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg52).getConstructor())
                          break Fail792;
                        n_423 = arg52.getSubterm(0);
                        term = termFactory.makeTuple(Simplify.const53, n_423);
                        term = subt$S_0_0.instance.invoke(context, term);
                        if(term == null)
                          break Fail792;
                        o_423 = term;
                        term = u_423.instance.invoke(context, o_423, this);
                        if(term == null)
                          break Fail792;
                        term = termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{term});
                        if(true)
                          break Success552;
                      }
                      term = term70;
                    }
                    Success553:
                    { 
                      if(cons85 == Simplify._consMul_2)
                      { 
                        Fail793:
                        { 
                          IStrategoTerm s_423 = null;
                          IStrategoTerm arg53 = term.getSubterm(0);
                          if(arg53.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg53).getConstructor())
                            break Fail793;
                          IStrategoTerm arg54 = arg53.getSubterm(0);
                          if(arg54.getTermType() != IStrategoTerm.STRING || !"1".equals(((IStrategoString)arg54).stringValue()))
                            break Fail793;
                          s_423 = term.getSubterm(1);
                          term = s_423;
                          if(true)
                            break Success553;
                        }
                        term = term70;
                      }
                      if(cons85 == Simplify._consMul_2)
                      { 
                        IStrategoTerm t_423 = null;
                        IStrategoTerm arg55 = term.getSubterm(0);
                        if(arg55.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg55).getConstructor())
                          break Fail775;
                        IStrategoTerm arg56 = arg55.getSubterm(0);
                        if(arg56.getTermType() != IStrategoTerm.STRING || !"-1".equals(((IStrategoString)arg56).stringValue()))
                          break Fail775;
                        t_423 = term.getSubterm(1);
                        term = termFactory.makeAppl(Simplify._consNeg_1, new IStrategoTerm[]{t_423});
                        term = this.invoke(context, term);
                        if(term == null)
                          break Fail775;
                      }
                      else
                      { 
                        break Fail775;
                      }
                    }
                  }
                }
              }
            }
            if(true)
              break Success535;
          }
          term = term53;
        }
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class u_423 extends Strategy 
  { 
    public static final u_423 instance = new u_423();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term, Strategy w_423)
    { 
      Fail794:
      { 
        lifted109 lifted1090 = new lifted109();
        lifted1090.w_423 = w_423;
        term = SRTS_all.instance.invoke(context, term, lifted1090);
        if(term == null)
          break Fail794;
        term = w_423.invoke(context, term);
        if(term == null)
          break Fail794;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted109 extends Strategy 
  { 
    Strategy w_423;

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail795:
      { 
        term = u_423.instance.invoke(context, term, w_423);
        if(term == null)
          break Fail795;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class h_418 extends Strategy 
  { 
    public static final h_418 instance = new h_418();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      ITermFactory termFactory = context.getFactory();
      Fail796:
      { 
        IStrategoTerm term45 = term;
        Success554:
        { 
          Fail797:
          { 
            IStrategoTerm term46 = term;
            IStrategoConstructor cons86 = term.getTermType() == IStrategoTerm.APPL ? ((IStrategoAppl)term).getConstructor() : null;
            Success555:
            { 
              if(cons86 == Simplify._consAdd_2)
              { 
                Fail798:
                { 
                  IStrategoTerm m_417 = null;
                  IStrategoTerm n_417 = null;
                  IStrategoTerm arg12 = term.getSubterm(0);
                  if(arg12.getTermType() != IStrategoTerm.APPL || Simplify._consNeg_1 != ((IStrategoAppl)arg12).getConstructor())
                    break Fail798;
                  m_417 = arg12.getSubterm(0);
                  n_417 = term.getSubterm(1);
                  term = n_417;
                  IStrategoTerm term47 = term;
                  Success556:
                  { 
                    Fail799:
                    { 
                      if(term.getTermType() != IStrategoTerm.APPL || Simplify._consNeg_1 != ((IStrategoAppl)term).getConstructor())
                        break Fail799;
                      { 
                        if(true)
                          break Fail798;
                        if(true)
                          break Success556;
                      }
                    }
                    term = term47;
                  }
                  term = n_417;
                  IStrategoTerm term48 = term;
                  Success557:
                  { 
                    Fail800:
                    { 
                      if(term.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)term).getConstructor())
                        break Fail800;
                      { 
                        if(true)
                          break Fail798;
                        if(true)
                          break Success557;
                      }
                    }
                    term = term48;
                  }
                  term = termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{n_417, termFactory.makeAppl(Simplify._consNeg_1, new IStrategoTerm[]{m_417})});
                  term = this.invoke(context, term);
                  if(term == null)
                    break Fail798;
                  if(true)
                    break Success555;
                }
                term = term46;
              }
              Success558:
              { 
                if(cons86 == Simplify._consAdd_2)
                { 
                  Fail801:
                  { 
                    IStrategoTerm p_417 = null;
                    IStrategoTerm q_417 = null;
                    IStrategoTerm r_417 = null;
                    IStrategoTerm arg15 = term.getSubterm(0);
                    if(arg15.getTermType() != IStrategoTerm.APPL || Simplify._consAdd_2 != ((IStrategoAppl)arg15).getConstructor())
                      break Fail801;
                    p_417 = arg15.getSubterm(0);
                    IStrategoTerm arg16 = arg15.getSubterm(1);
                    if(arg16.getTermType() != IStrategoTerm.APPL || Simplify._consNeg_1 != ((IStrategoAppl)arg16).getConstructor())
                      break Fail801;
                    q_417 = arg16.getSubterm(0);
                    r_417 = term.getSubterm(1);
                    term = r_417;
                    IStrategoTerm term50 = term;
                    Success559:
                    { 
                      Fail802:
                      { 
                        if(term.getTermType() != IStrategoTerm.APPL || Simplify._consNeg_1 != ((IStrategoAppl)term).getConstructor())
                          break Fail802;
                        { 
                          if(true)
                            break Fail801;
                          if(true)
                            break Success559;
                        }
                      }
                      term = term50;
                    }
                    term = r_417;
                    IStrategoTerm term51 = term;
                    Success560:
                    { 
                      Fail803:
                      { 
                        if(term.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)term).getConstructor())
                          break Fail803;
                        { 
                          if(true)
                            break Fail801;
                          if(true)
                            break Success560;
                        }
                      }
                      term = term51;
                    }
                    term = termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{p_417, r_417});
                    term = this.invoke(context, term);
                    if(term == null)
                      break Fail801;
                    term = termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{term, termFactory.makeAppl(Simplify._consNeg_1, new IStrategoTerm[]{q_417})});
                    term = this.invoke(context, term);
                    if(term == null)
                      break Fail801;
                    if(true)
                      break Success558;
                  }
                  term = term46;
                }
                Success561:
                { 
                  if(cons86 == Simplify._consAdd_2)
                  { 
                    Fail804:
                    { 
                      IStrategoTerm v_417 = null;
                      IStrategoTerm w_417 = null;
                      IStrategoTerm x_417 = null;
                      IStrategoTerm arg19 = term.getSubterm(0);
                      if(arg19.getTermType() != IStrategoTerm.APPL || Simplify._consNeg_1 != ((IStrategoAppl)arg19).getConstructor())
                        break Fail804;
                      IStrategoTerm arg20 = arg19.getSubterm(0);
                      if(arg20.getTermType() != IStrategoTerm.APPL || Simplify._consMul_2 != ((IStrategoAppl)arg20).getConstructor())
                        break Fail804;
                      w_417 = arg20.getSubterm(0);
                      IStrategoTerm arg21 = arg20.getSubterm(1);
                      if(arg21.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg21).getConstructor())
                        break Fail804;
                      IStrategoTerm arg22 = arg21.getSubterm(0);
                      if(arg22.getTermType() != IStrategoTerm.STRING || !"1".equals(((IStrategoString)arg22).stringValue()))
                        break Fail804;
                      IStrategoTerm arg23 = term.getSubterm(1);
                      if(arg23.getTermType() != IStrategoTerm.APPL || Simplify._consNeg_1 != ((IStrategoAppl)arg23).getConstructor())
                        break Fail804;
                      IStrategoTerm arg24 = arg23.getSubterm(0);
                      if(arg24.getTermType() != IStrategoTerm.APPL || Simplify._consMul_2 != ((IStrategoAppl)arg24).getConstructor())
                        break Fail804;
                      v_417 = arg24.getSubterm(0);
                      IStrategoTerm arg25 = arg24.getSubterm(1);
                      if(arg25.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg25).getConstructor())
                        break Fail804;
                      x_417 = arg25.getSubterm(0);
                      term = termFactory.makeTuple(x_417, Simplify.const54);
                      term = gt$S_0_0.instance.invoke(context, term);
                      if(term == null)
                        break Fail804;
                      term = termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consNeg_1, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{v_417, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{x_417})})}), termFactory.makeAppl(Simplify._consNeg_1, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{w_417, Simplify.constInt0})})});
                      term = this.invoke(context, term);
                      if(term == null)
                        break Fail804;
                      if(true)
                        break Success561;
                    }
                    term = term46;
                  }
                  if(cons86 == Simplify._consAdd_2)
                  { 
                    IStrategoTerm z_417 = null;
                    IStrategoTerm a_418 = null;
                    IStrategoTerm b_418 = null;
                    IStrategoTerm c_418 = null;
                    IStrategoTerm arg26 = term.getSubterm(0);
                    if(arg26.getTermType() != IStrategoTerm.APPL || Simplify._consAdd_2 != ((IStrategoAppl)arg26).getConstructor())
                      break Fail797;
                    z_417 = arg26.getSubterm(0);
                    IStrategoTerm arg27 = arg26.getSubterm(1);
                    if(arg27.getTermType() != IStrategoTerm.APPL || Simplify._consNeg_1 != ((IStrategoAppl)arg27).getConstructor())
                      break Fail797;
                    IStrategoTerm arg28 = arg27.getSubterm(0);
                    if(arg28.getTermType() != IStrategoTerm.APPL || Simplify._consMul_2 != ((IStrategoAppl)arg28).getConstructor())
                      break Fail797;
                    b_418 = arg28.getSubterm(0);
                    IStrategoTerm arg29 = arg28.getSubterm(1);
                    if(arg29.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg29).getConstructor())
                      break Fail797;
                    IStrategoTerm arg30 = arg29.getSubterm(0);
                    if(arg30.getTermType() != IStrategoTerm.STRING || !"1".equals(((IStrategoString)arg30).stringValue()))
                      break Fail797;
                    IStrategoTerm arg31 = term.getSubterm(1);
                    if(arg31.getTermType() != IStrategoTerm.APPL || Simplify._consNeg_1 != ((IStrategoAppl)arg31).getConstructor())
                      break Fail797;
                    IStrategoTerm arg32 = arg31.getSubterm(0);
                    if(arg32.getTermType() != IStrategoTerm.APPL || Simplify._consMul_2 != ((IStrategoAppl)arg32).getConstructor())
                      break Fail797;
                    a_418 = arg32.getSubterm(0);
                    IStrategoTerm arg33 = arg32.getSubterm(1);
                    if(arg33.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg33).getConstructor())
                      break Fail797;
                    c_418 = arg33.getSubterm(0);
                    term = termFactory.makeTuple(c_418, Simplify.const54);
                    term = gt$S_0_0.instance.invoke(context, term);
                    if(term == null)
                      break Fail797;
                    term = termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{z_417, termFactory.makeAppl(Simplify._consNeg_1, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{a_418, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{c_418})})})});
                    term = this.invoke(context, term);
                    if(term == null)
                      break Fail797;
                    term = termFactory.makeAppl(Simplify._consAdd_2, new IStrategoTerm[]{term, termFactory.makeAppl(Simplify._consNeg_1, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{b_418, Simplify.constInt0})})});
                    term = this.invoke(context, term);
                    if(term == null)
                      break Fail797;
                  }
                  else
                  { 
                    break Fail797;
                  }
                }
              }
            }
            if(true)
              break Success554;
          }
          term = term45;
        }
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class g_418 extends Strategy 
  { 
    public static final g_418 instance = new g_418();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term, Strategy i_418)
    { 
      Fail805:
      { 
        lifted108 lifted1080 = new lifted108();
        lifted1080.i_418 = i_418;
        term = SRTS_all.instance.invoke(context, term, lifted1080);
        if(term == null)
          break Fail805;
        term = i_418.invoke(context, term);
        if(term == null)
          break Fail805;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted108 extends Strategy 
  { 
    Strategy i_418;

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail806:
      { 
        term = g_418.instance.invoke(context, term, i_418);
        if(term == null)
          break Fail806;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class p_416 extends Strategy 
  { 
    public static final p_416 instance = new p_416();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      ITermFactory termFactory = context.getFactory();
      Fail807:
      { 
        IStrategoTerm term40 = term;
        Success562:
        { 
          Fail808:
          { 
            IStrategoTerm term41 = term;
            IStrategoConstructor cons91 = term.getTermType() == IStrategoTerm.APPL ? ((IStrategoAppl)term).getConstructor() : null;
            Success563:
            { 
              if(cons91 == Simplify._consMul_2)
              { 
                Fail809:
                { 
                  IStrategoTerm y_415 = null;
                  IStrategoTerm z_415 = null;
                  IStrategoTerm arg5 = term.getSubterm(0);
                  if(arg5.getTermType() != IStrategoTerm.APPL || Simplify._consNeg_1 != ((IStrategoAppl)arg5).getConstructor())
                    break Fail809;
                  y_415 = arg5.getSubterm(0);
                  IStrategoTerm arg6 = term.getSubterm(1);
                  if(arg6.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg6).getConstructor())
                    break Fail809;
                  z_415 = arg6.getSubterm(0);
                  term = termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{y_415, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{z_415})});
                  term = this.invoke(context, term);
                  if(term == null)
                    break Fail809;
                  term = termFactory.makeAppl(Simplify._consNeg_1, new IStrategoTerm[]{term});
                  term = this.invoke(context, term);
                  if(term == null)
                    break Fail809;
                  if(true)
                    break Success563;
                }
                term = term41;
              }
              Success564:
              { 
                if(cons91 == Simplify._consMul_2)
                { 
                  Fail810:
                  { 
                    IStrategoTerm c_416 = null;
                    IStrategoTerm d_416 = null;
                    IStrategoTerm e_416 = null;
                    c_416 = term.getSubterm(0);
                    IStrategoTerm arg7 = term.getSubterm(1);
                    if(arg7.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg7).getConstructor())
                      break Fail810;
                    d_416 = arg7.getSubterm(0);
                    term = termFactory.makeTuple(d_416, Simplify.const53);
                    term = lt$S_0_0.instance.invoke(context, term);
                    if(term == null)
                      break Fail810;
                    term = termFactory.makeTuple(Simplify.const53, d_416);
                    term = subt$S_0_0.instance.invoke(context, term);
                    if(term == null)
                      break Fail810;
                    e_416 = term;
                    term = o_416.instance.invoke(context, e_416, this);
                    if(term == null)
                      break Fail810;
                    term = termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{c_416, termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{term})});
                    term = this.invoke(context, term);
                    if(term == null)
                      break Fail810;
                    term = termFactory.makeAppl(Simplify._consNeg_1, new IStrategoTerm[]{term});
                    term = this.invoke(context, term);
                    if(term == null)
                      break Fail810;
                    if(true)
                      break Success564;
                  }
                  term = term41;
                }
                if(cons91 == Simplify._consNeg_1)
                { 
                  IStrategoTerm k_416 = null;
                  k_416 = term.getSubterm(0);
                  term = k_416;
                  IStrategoTerm term43 = term;
                  Success565:
                  { 
                    Fail811:
                    { 
                      if(term.getTermType() != IStrategoTerm.APPL || Simplify._consMul_2 != ((IStrategoAppl)term).getConstructor())
                        break Fail811;
                      IStrategoTerm arg9 = term.getSubterm(1);
                      if(arg9.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg9).getConstructor())
                        break Fail811;
                      { 
                        if(true)
                          break Fail808;
                        if(true)
                          break Success565;
                      }
                    }
                    term = term43;
                  }
                  term = k_416;
                  IStrategoTerm term44 = term;
                  Success566:
                  { 
                    Fail812:
                    { 
                      if(term.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)term).getConstructor())
                        break Fail812;
                      { 
                        if(true)
                          break Fail808;
                        if(true)
                          break Success566;
                      }
                    }
                    term = term44;
                  }
                  term = termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{k_416, Simplify.constInt0});
                  term = this.invoke(context, term);
                  if(term == null)
                    break Fail808;
                  term = termFactory.makeAppl(Simplify._consNeg_1, new IStrategoTerm[]{term});
                  term = this.invoke(context, term);
                  if(term == null)
                    break Fail808;
                }
                else
                { 
                  break Fail808;
                }
              }
            }
            if(true)
              break Success562;
          }
          term = term40;
        }
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class o_416 extends Strategy 
  { 
    public static final o_416 instance = new o_416();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term, Strategy q_416)
    { 
      Fail813:
      { 
        lifted107 lifted1070 = new lifted107();
        lifted1070.q_416 = q_416;
        term = SRTS_all.instance.invoke(context, term, lifted1070);
        if(term == null)
          break Fail813;
        term = q_416.invoke(context, term);
        if(term == null)
          break Fail813;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted107 extends Strategy 
  { 
    Strategy q_416;

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail814:
      { 
        term = o_416.instance.invoke(context, term, q_416);
        if(term == null)
          break Fail814;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class l_424 extends Strategy 
  { 
    public static final l_424 instance = new l_424();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      ITermFactory termFactory = context.getFactory();
      Fail815:
      { 
        IStrategoTerm term39 = term;
        Success567:
        { 
          Fail816:
          { 
            IStrategoTerm e_424 = null;
            IStrategoTerm f_424 = null;
            IStrategoTerm g_424 = null;
            if(term.getTermType() != IStrategoTerm.APPL || Simplify._consNeg_1 != ((IStrategoAppl)term).getConstructor())
              break Fail816;
            IStrategoTerm arg3 = term.getSubterm(0);
            if(arg3.getTermType() != IStrategoTerm.APPL || Simplify._consMul_2 != ((IStrategoAppl)arg3).getConstructor())
              break Fail816;
            IStrategoTerm arg4 = arg3.getSubterm(0);
            if(arg4.getTermType() != IStrategoTerm.APPL || Simplify._consInt_1 != ((IStrategoAppl)arg4).getConstructor())
              break Fail816;
            f_424 = arg4.getSubterm(0);
            e_424 = arg3.getSubterm(1);
            term = termFactory.makeTuple(Simplify.const53, f_424);
            term = subt$S_0_0.instance.invoke(context, term);
            if(term == null)
              break Fail816;
            g_424 = term;
            term = k_424.instance.invoke(context, g_424, this);
            if(term == null)
              break Fail816;
            term = termFactory.makeAppl(Simplify._consMul_2, new IStrategoTerm[]{termFactory.makeAppl(Simplify._consInt_1, new IStrategoTerm[]{term}), e_424});
            if(true)
              break Success567;
          }
          term = term39;
        }
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class k_424 extends Strategy 
  { 
    public static final k_424 instance = new k_424();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term, Strategy m_424)
    { 
      Fail817:
      { 
        lifted110 lifted1100 = new lifted110();
        lifted1100.m_424 = m_424;
        term = SRTS_all.instance.invoke(context, term, lifted1100);
        if(term == null)
          break Fail817;
        term = m_424.invoke(context, term);
        if(term == null)
          break Fail817;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted110 extends Strategy 
  { 
    Strategy m_424;

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail818:
      { 
        term = k_424.instance.invoke(context, term, m_424);
        if(term == null)
          break Fail818;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted106 extends Strategy 
  { 
    TermReference o_26;

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail819:
      { 
        if(o_26.value == null)
          break Fail819;
        term = rm_config_0_0.instance.invoke(context, o_26.value);
        if(term == null)
          break Fail819;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted105 extends Strategy 
  { 
    public static final lifted105 instance = new lifted105();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail820:
      { 
        IStrategoTerm a_26 = null;
        a_26 = term;
        term = get_option_0_1.instance.invoke(context, a_26, Simplify.constNo_use_apply_assertions0);
        if(term == null)
          break Fail820;
        term = rm_config_0_0.instance.invoke(context, Simplify.constUse_apply_assertions0);
        if(term == null)
          break Fail820;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted104 extends Strategy 
  { 
    public static final lifted104 instance = new lifted104();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail821:
      { 
        IStrategoTerm y_25 = null;
        y_25 = term;
        term = get_option_0_1.instance.invoke(context, y_25, Simplify.constNo_use_program_assertions0);
        if(term == null)
          break Fail821;
        term = rm_config_0_0.instance.invoke(context, Simplify.constUse_program_assertions0);
        if(term == null)
          break Fail821;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted103 extends Strategy 
  { 
    public static final lifted103 instance = new lifted103();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail822:
      { 
        IStrategoTerm w_25 = null;
        w_25 = term;
        term = get_option_0_1.instance.invoke(context, w_25, Simplify.constNo_generate_loop_assertions0);
        if(term == null)
          break Fail822;
        term = rm_config_0_0.instance.invoke(context, Simplify.constGenerate_loop_assertions0);
        if(term == null)
          break Fail822;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted102 extends Strategy 
  { 
    public static final lifted102 instance = new lifted102();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail823:
      { 
        IStrategoTerm u_25 = null;
        u_25 = term;
        term = get_option_0_1.instance.invoke(context, u_25, Simplify.constNo_generate_if_assertions0);
        if(term == null)
          break Fail823;
        term = rm_config_0_0.instance.invoke(context, Simplify.constGenerate_if_assertions0);
        if(term == null)
          break Fail823;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted101 extends Strategy 
  { 
    public static final lifted101 instance = new lifted101();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail824:
      { 
        IStrategoTerm s_25 = null;
        s_25 = term;
        term = get_option_0_1.instance.invoke(context, s_25, Simplify.constNo_normalise_expressions0);
        if(term == null)
          break Fail824;
        term = rm_config_0_0.instance.invoke(context, Simplify.constNormalise_expressions0);
        if(term == null)
          break Fail824;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted100 extends Strategy 
  { 
    public static final lifted100 instance = new lifted100();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail825:
      { 
        IStrategoTerm q_25 = null;
        q_25 = term;
        term = get_option_0_1.instance.invoke(context, q_25, Simplify.constNo_propagate_constant_assignments0);
        if(term == null)
          break Fail825;
        term = rm_config_0_0.instance.invoke(context, Simplify.constPropagate_constant_assignments0);
        if(term == null)
          break Fail825;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted99 extends Strategy 
  { 
    public static final lifted99 instance = new lifted99();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail826:
      { 
        IStrategoTerm o_25 = null;
        o_25 = term;
        term = get_option_0_1.instance.invoke(context, o_25, Simplify.constNo_evaluate_constant_expressions0);
        if(term == null)
          break Fail826;
        term = rm_config_0_0.instance.invoke(context, Simplify.constEvaluate_constant_expressions0);
        if(term == null)
          break Fail826;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted98 extends Strategy 
  { 
    public static final lifted98 instance = new lifted98();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail827:
      { 
        IStrategoTerm m_25 = null;
        m_25 = term;
        term = get_option_0_1.instance.invoke(context, m_25, Simplify.constOptimise_20);
        if(term == null)
          break Fail827;
        term = set_config_0_0.instance.invoke(context, Simplify.const29);
        if(term == null)
          break Fail827;
        term = set_config_0_0.instance.invoke(context, Simplify.const33);
        if(term == null)
          break Fail827;
        term = set_config_0_0.instance.invoke(context, Simplify.const31);
        if(term == null)
          break Fail827;
        term = set_config_0_0.instance.invoke(context, Simplify.const35);
        if(term == null)
          break Fail827;
        term = set_config_0_0.instance.invoke(context, Simplify.const37);
        if(term == null)
          break Fail827;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted97 extends Strategy 
  { 
    public static final lifted97 instance = new lifted97();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail828:
      { 
        IStrategoTerm k_25 = null;
        k_25 = term;
        term = get_option_0_1.instance.invoke(context, k_25, Simplify.constOptimise_10);
        if(term == null)
          break Fail828;
        term = set_config_0_0.instance.invoke(context, Simplify.const29);
        if(term == null)
          break Fail828;
        term = set_config_0_0.instance.invoke(context, Simplify.const33);
        if(term == null)
          break Fail828;
        term = set_config_0_0.instance.invoke(context, Simplify.const31);
        if(term == null)
          break Fail828;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted96 extends Strategy 
  { 
    public static final lifted96 instance = new lifted96();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail829:
      { 
        term = option_group_default_0_0.instance.invoke(context, Simplify.constCons15);
        if(term == null)
          break Fail829;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted95 extends Strategy 
  { 
    public static final lifted95 instance = new lifted95();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail830:
      { 
        term = mutually_exclusive_options_default_0_0.instance.invoke(context, Simplify.constCons12);
        if(term == null)
          break Fail830;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted94 extends Strategy 
  { 
    public static final lifted94 instance = new lifted94();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail831:
      { 
        term = mutually_exclusive_options_default_0_0.instance.invoke(context, Simplify.constCons9);
        if(term == null)
          break Fail831;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted93 extends Strategy 
  { 
    public static final lifted93 instance = new lifted93();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail832:
      { 
        term = mutually_exclusive_options_default_0_0.instance.invoke(context, Simplify.constCons5);
        if(term == null)
          break Fail832;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted91 extends Strategy 
  { 
    public static final lifted91 instance = new lifted91();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail833:
      { 
        IStrategoTerm i_25 = null;
        i_25 = term;
        term = get_option_0_1.instance.invoke(context, i_25, Simplify.constSimple0);
        if(term == null)
          break Fail833;
        term = try_1_0.instance.invoke(context, term, lifted92.instance);
        if(term == null)
          break Fail833;
        term = set_config_0_0.instance.invoke(context, Simplify.const5);
        if(term == null)
          break Fail833;
        term = set_config_0_0.instance.invoke(context, Simplify.const17);
        if(term == null)
          break Fail833;
        term = set_config_0_0.instance.invoke(context, Simplify.const11);
        if(term == null)
          break Fail833;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted92 extends Strategy 
  { 
    public static final lifted92 instance = new lifted92();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail834:
      { 
        term = option_group_default_0_0.instance.invoke(context, Simplify.constCons2);
        if(term == null)
          break Fail834;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted90 extends Strategy 
  { 
    public static final lifted90 instance = new lifted90();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail835:
      { 
        IStrategoTerm g_25 = null;
        g_25 = term;
        term = get_option_0_1.instance.invoke(context, g_25, Simplify.constTest0);
        if(term == null)
          break Fail835;
        term = set_config_0_0.instance.invoke(context, Simplify.const1);
        if(term == null)
          break Fail835;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted89 extends Strategy 
  { 
    public static final lifted89 instance = new lifted89();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail836:
      { 
        if(term.getTermType() != IStrategoTerm.LIST || !((IStrategoList)term).isEmpty())
          break Fail836;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted88 extends Strategy 
  { 
    public static final lifted88 instance = new lifted88();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail837:
      { 
        term = set_config_0_0.instance.invoke(context, Simplify.const51);
        if(term == null)
          break Fail837;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted87 extends Strategy 
  { 
    public static final lifted87 instance = new lifted87();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail838:
      { 
        if(term.getTermType() != IStrategoTerm.STRING || !"--no-use-apply-assertions".equals(((IStrategoString)term).stringValue()))
          break Fail838;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted86 extends Strategy 
  { 
    public static final lifted86 instance = new lifted86();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail839:
      { 
        if(term.getTermType() != IStrategoTerm.LIST || !((IStrategoList)term).isEmpty())
          break Fail839;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted85 extends Strategy 
  { 
    public static final lifted85 instance = new lifted85();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail840:
      { 
        term = set_config_0_0.instance.invoke(context, Simplify.const50);
        if(term == null)
          break Fail840;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted84 extends Strategy 
  { 
    public static final lifted84 instance = new lifted84();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail841:
      { 
        if(term.getTermType() != IStrategoTerm.STRING || !"--no-use-program-assertions".equals(((IStrategoString)term).stringValue()))
          break Fail841;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted83 extends Strategy 
  { 
    public static final lifted83 instance = new lifted83();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail842:
      { 
        if(term.getTermType() != IStrategoTerm.LIST || !((IStrategoList)term).isEmpty())
          break Fail842;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted82 extends Strategy 
  { 
    public static final lifted82 instance = new lifted82();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail843:
      { 
        term = set_config_0_0.instance.invoke(context, Simplify.const49);
        if(term == null)
          break Fail843;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted81 extends Strategy 
  { 
    public static final lifted81 instance = new lifted81();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail844:
      { 
        if(term.getTermType() != IStrategoTerm.STRING || !"--no-generate-loop-assertions".equals(((IStrategoString)term).stringValue()))
          break Fail844;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted80 extends Strategy 
  { 
    public static final lifted80 instance = new lifted80();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail845:
      { 
        if(term.getTermType() != IStrategoTerm.LIST || !((IStrategoList)term).isEmpty())
          break Fail845;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted79 extends Strategy 
  { 
    public static final lifted79 instance = new lifted79();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail846:
      { 
        term = set_config_0_0.instance.invoke(context, Simplify.const48);
        if(term == null)
          break Fail846;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted78 extends Strategy 
  { 
    public static final lifted78 instance = new lifted78();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail847:
      { 
        if(term.getTermType() != IStrategoTerm.STRING || !"--no-generate-if-assertions".equals(((IStrategoString)term).stringValue()))
          break Fail847;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted77 extends Strategy 
  { 
    public static final lifted77 instance = new lifted77();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail848:
      { 
        if(term.getTermType() != IStrategoTerm.LIST || !((IStrategoList)term).isEmpty())
          break Fail848;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted76 extends Strategy 
  { 
    public static final lifted76 instance = new lifted76();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail849:
      { 
        term = set_config_0_0.instance.invoke(context, Simplify.const47);
        if(term == null)
          break Fail849;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted75 extends Strategy 
  { 
    public static final lifted75 instance = new lifted75();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail850:
      { 
        if(term.getTermType() != IStrategoTerm.STRING || !"--no-normalise-expressions".equals(((IStrategoString)term).stringValue()))
          break Fail850;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted74 extends Strategy 
  { 
    public static final lifted74 instance = new lifted74();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail851:
      { 
        if(term.getTermType() != IStrategoTerm.LIST || !((IStrategoList)term).isEmpty())
          break Fail851;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted73 extends Strategy 
  { 
    public static final lifted73 instance = new lifted73();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail852:
      { 
        term = set_config_0_0.instance.invoke(context, Simplify.const46);
        if(term == null)
          break Fail852;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted72 extends Strategy 
  { 
    public static final lifted72 instance = new lifted72();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail853:
      { 
        if(term.getTermType() != IStrategoTerm.STRING || !"--no-propagate-constant-assignments".equals(((IStrategoString)term).stringValue()))
          break Fail853;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted71 extends Strategy 
  { 
    public static final lifted71 instance = new lifted71();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail854:
      { 
        if(term.getTermType() != IStrategoTerm.LIST || !((IStrategoList)term).isEmpty())
          break Fail854;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted70 extends Strategy 
  { 
    public static final lifted70 instance = new lifted70();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail855:
      { 
        term = set_config_0_0.instance.invoke(context, Simplify.const45);
        if(term == null)
          break Fail855;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted69 extends Strategy 
  { 
    public static final lifted69 instance = new lifted69();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail856:
      { 
        if(term.getTermType() != IStrategoTerm.STRING || !"--no-evaluate-constant-expressions".equals(((IStrategoString)term).stringValue()))
          break Fail856;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted68 extends Strategy 
  { 
    public static final lifted68 instance = new lifted68();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail857:
      { 
        term = Simplify.const44;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted67 extends Strategy 
  { 
    public static final lifted67 instance = new lifted67();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail858:
      { 
        term = set_config_0_0.instance.invoke(context, Simplify.const43);
        if(term == null)
          break Fail858;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted66 extends Strategy 
  { 
    public static final lifted66 instance = new lifted66();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail859:
      { 
        if(term.getTermType() != IStrategoTerm.STRING || !"--merge-complex-multiply".equals(((IStrategoString)term).stringValue()))
          break Fail859;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted65 extends Strategy 
  { 
    public static final lifted65 instance = new lifted65();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail860:
      { 
        term = Simplify.const42;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted64 extends Strategy 
  { 
    public static final lifted64 instance = new lifted64();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail861:
      { 
        term = set_config_0_0.instance.invoke(context, Simplify.const41);
        if(term == null)
          break Fail861;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted63 extends Strategy 
  { 
    public static final lifted63 instance = new lifted63();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail862:
      { 
        if(term.getTermType() != IStrategoTerm.STRING || !"--use-apply-assertions".equals(((IStrategoString)term).stringValue()))
          break Fail862;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted62 extends Strategy 
  { 
    public static final lifted62 instance = new lifted62();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail863:
      { 
        term = Simplify.const40;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted61 extends Strategy 
  { 
    public static final lifted61 instance = new lifted61();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail864:
      { 
        term = set_config_0_0.instance.invoke(context, Simplify.const39);
        if(term == null)
          break Fail864;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted60 extends Strategy 
  { 
    public static final lifted60 instance = new lifted60();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail865:
      { 
        if(term.getTermType() != IStrategoTerm.STRING || !"--use-program-assertions".equals(((IStrategoString)term).stringValue()))
          break Fail865;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted59 extends Strategy 
  { 
    public static final lifted59 instance = new lifted59();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail866:
      { 
        term = Simplify.const38;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted58 extends Strategy 
  { 
    public static final lifted58 instance = new lifted58();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail867:
      { 
        term = set_config_0_0.instance.invoke(context, Simplify.const37);
        if(term == null)
          break Fail867;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted57 extends Strategy 
  { 
    public static final lifted57 instance = new lifted57();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail868:
      { 
        if(term.getTermType() != IStrategoTerm.STRING || !"--generate-loop-assertions".equals(((IStrategoString)term).stringValue()))
          break Fail868;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted56 extends Strategy 
  { 
    public static final lifted56 instance = new lifted56();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail869:
      { 
        term = Simplify.const36;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted55 extends Strategy 
  { 
    public static final lifted55 instance = new lifted55();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail870:
      { 
        term = set_config_0_0.instance.invoke(context, Simplify.const35);
        if(term == null)
          break Fail870;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted54 extends Strategy 
  { 
    public static final lifted54 instance = new lifted54();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail871:
      { 
        if(term.getTermType() != IStrategoTerm.STRING || !"--generate-if-assertions".equals(((IStrategoString)term).stringValue()))
          break Fail871;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted53 extends Strategy 
  { 
    public static final lifted53 instance = new lifted53();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail872:
      { 
        term = Simplify.const34;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted52 extends Strategy 
  { 
    public static final lifted52 instance = new lifted52();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail873:
      { 
        term = set_config_0_0.instance.invoke(context, Simplify.const33);
        if(term == null)
          break Fail873;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted51 extends Strategy 
  { 
    public static final lifted51 instance = new lifted51();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail874:
      { 
        if(term.getTermType() != IStrategoTerm.STRING || !"--propagate-constant-assignments".equals(((IStrategoString)term).stringValue()))
          break Fail874;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted50 extends Strategy 
  { 
    public static final lifted50 instance = new lifted50();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail875:
      { 
        term = Simplify.const32;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted49 extends Strategy 
  { 
    public static final lifted49 instance = new lifted49();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail876:
      { 
        term = set_config_0_0.instance.invoke(context, Simplify.const31);
        if(term == null)
          break Fail876;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted48 extends Strategy 
  { 
    public static final lifted48 instance = new lifted48();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail877:
      { 
        if(term.getTermType() != IStrategoTerm.STRING || !"--normalise-expressions".equals(((IStrategoString)term).stringValue()))
          break Fail877;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted47 extends Strategy 
  { 
    public static final lifted47 instance = new lifted47();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail878:
      { 
        term = Simplify.const30;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted46 extends Strategy 
  { 
    public static final lifted46 instance = new lifted46();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail879:
      { 
        term = set_config_0_0.instance.invoke(context, Simplify.const29);
        if(term == null)
          break Fail879;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted45 extends Strategy 
  { 
    public static final lifted45 instance = new lifted45();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail880:
      { 
        if(term.getTermType() != IStrategoTerm.STRING || !"--evaluate-constant-expressions".equals(((IStrategoString)term).stringValue()))
          break Fail880;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted44 extends Strategy 
  { 
    public static final lifted44 instance = new lifted44();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail881:
      { 
        term = Simplify.const28;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted43 extends Strategy 
  { 
    public static final lifted43 instance = new lifted43();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail882:
      { 
        term = set_config_0_0.instance.invoke(context, Simplify.const27);
        if(term == null)
          break Fail882;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted42 extends Strategy 
  { 
    public static final lifted42 instance = new lifted42();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail883:
      { 
        if(term.getTermType() != IStrategoTerm.STRING || !"--optimise-2".equals(((IStrategoString)term).stringValue()))
          break Fail883;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted41 extends Strategy 
  { 
    public static final lifted41 instance = new lifted41();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail884:
      { 
        term = Simplify.const26;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted40 extends Strategy 
  { 
    public static final lifted40 instance = new lifted40();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail885:
      { 
        term = set_config_0_0.instance.invoke(context, Simplify.const25);
        if(term == null)
          break Fail885;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted39 extends Strategy 
  { 
    public static final lifted39 instance = new lifted39();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail886:
      { 
        if(term.getTermType() != IStrategoTerm.STRING || !"--optimise-1".equals(((IStrategoString)term).stringValue()))
          break Fail886;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted38 extends Strategy 
  { 
    public static final lifted38 instance = new lifted38();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail887:
      { 
        term = Simplify.const24;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted37 extends Strategy 
  { 
    public static final lifted37 instance = new lifted37();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail888:
      { 
        term = set_config_0_0.instance.invoke(context, Simplify.const23);
        if(term == null)
          break Fail888;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted36 extends Strategy 
  { 
    public static final lifted36 instance = new lifted36();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail889:
      { 
        if(term.getTermType() != IStrategoTerm.STRING || !"--optimise-0".equals(((IStrategoString)term).stringValue()))
          break Fail889;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted35 extends Strategy 
  { 
    public static final lifted35 instance = new lifted35();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail890:
      { 
        term = Simplify.const22;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted34 extends Strategy 
  { 
    public static final lifted34 instance = new lifted34();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail891:
      { 
        term = set_config_0_0.instance.invoke(context, Simplify.const21);
        if(term == null)
          break Fail891;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted33 extends Strategy 
  { 
    public static final lifted33 instance = new lifted33();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail892:
      { 
        if(term.getTermType() != IStrategoTerm.STRING || !"--width-512".equals(((IStrategoString)term).stringValue()))
          break Fail892;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted32 extends Strategy 
  { 
    public static final lifted32 instance = new lifted32();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail893:
      { 
        term = Simplify.const20;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted31 extends Strategy 
  { 
    public static final lifted31 instance = new lifted31();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail894:
      { 
        term = set_config_0_0.instance.invoke(context, Simplify.const19);
        if(term == null)
          break Fail894;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted30 extends Strategy 
  { 
    public static final lifted30 instance = new lifted30();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail895:
      { 
        if(term.getTermType() != IStrategoTerm.STRING || !"--loop-nosingle".equals(((IStrategoString)term).stringValue()))
          break Fail895;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted29 extends Strategy 
  { 
    public static final lifted29 instance = new lifted29();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail896:
      { 
        term = Simplify.const18;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted28 extends Strategy 
  { 
    public static final lifted28 instance = new lifted28();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail897:
      { 
        term = set_config_0_0.instance.invoke(context, Simplify.const17);
        if(term == null)
          break Fail897;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted27 extends Strategy 
  { 
    public static final lifted27 instance = new lifted27();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail898:
      { 
        if(term.getTermType() != IStrategoTerm.STRING || !"--loop-raster".equals(((IStrategoString)term).stringValue()))
          break Fail898;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted26 extends Strategy 
  { 
    public static final lifted26 instance = new lifted26();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail899:
      { 
        term = Simplify.const16;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted25 extends Strategy 
  { 
    public static final lifted25 instance = new lifted25();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail900:
      { 
        term = set_config_0_0.instance.invoke(context, Simplify.const15);
        if(term == null)
          break Fail900;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted24 extends Strategy 
  { 
    public static final lifted24 instance = new lifted24();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail901:
      { 
        if(term.getTermType() != IStrategoTerm.STRING || !"--loop-block".equals(((IStrategoString)term).stringValue()))
          break Fail901;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted23 extends Strategy 
  { 
    public static final lifted23 instance = new lifted23();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail902:
      { 
        term = Simplify.const14;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted22 extends Strategy 
  { 
    public static final lifted22 instance = new lifted22();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail903:
      { 
        term = set_config_0_0.instance.invoke(context, Simplify.const13);
        if(term == null)
          break Fail903;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted21 extends Strategy 
  { 
    public static final lifted21 instance = new lifted21();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail904:
      { 
        if(term.getTermType() != IStrategoTerm.STRING || !"--loop-index".equals(((IStrategoString)term).stringValue()))
          break Fail904;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted20 extends Strategy 
  { 
    public static final lifted20 instance = new lifted20();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail905:
      { 
        term = Simplify.const12;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted19 extends Strategy 
  { 
    public static final lifted19 instance = new lifted19();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail906:
      { 
        term = set_config_0_0.instance.invoke(context, Simplify.const11);
        if(term == null)
          break Fail906;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted18 extends Strategy 
  { 
    public static final lifted18 instance = new lifted18();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail907:
      { 
        if(term.getTermType() != IStrategoTerm.STRING || !"--loop-noindex".equals(((IStrategoString)term).stringValue()))
          break Fail907;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted17 extends Strategy 
  { 
    public static final lifted17 instance = new lifted17();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail908:
      { 
        term = Simplify.const10;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted16 extends Strategy 
  { 
    public static final lifted16 instance = new lifted16();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail909:
      { 
        term = set_config_0_0.instance.invoke(context, Simplify.const9);
        if(term == null)
          break Fail909;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted15 extends Strategy 
  { 
    public static final lifted15 instance = new lifted15();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail910:
      { 
        if(term.getTermType() != IStrategoTerm.STRING || !"--loop-10".equals(((IStrategoString)term).stringValue()))
          break Fail910;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted14 extends Strategy 
  { 
    public static final lifted14 instance = new lifted14();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail911:
      { 
        term = Simplify.const8;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted13 extends Strategy 
  { 
    public static final lifted13 instance = new lifted13();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail912:
      { 
        term = set_config_0_0.instance.invoke(context, Simplify.const7);
        if(term == null)
          break Fail912;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted12 extends Strategy 
  { 
    public static final lifted12 instance = new lifted12();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail913:
      { 
        if(term.getTermType() != IStrategoTerm.STRING || !"--loop-2".equals(((IStrategoString)term).stringValue()))
          break Fail913;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted11 extends Strategy 
  { 
    public static final lifted11 instance = new lifted11();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail914:
      { 
        term = Simplify.const6;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted10 extends Strategy 
  { 
    public static final lifted10 instance = new lifted10();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail915:
      { 
        term = set_config_0_0.instance.invoke(context, Simplify.const5);
        if(term == null)
          break Fail915;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted9 extends Strategy 
  { 
    public static final lifted9 instance = new lifted9();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail916:
      { 
        if(term.getTermType() != IStrategoTerm.STRING || !"--loop-1".equals(((IStrategoString)term).stringValue()))
          break Fail916;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted8 extends Strategy 
  { 
    public static final lifted8 instance = new lifted8();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail917:
      { 
        term = Simplify.const4;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted7 extends Strategy 
  { 
    public static final lifted7 instance = new lifted7();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail918:
      { 
        term = set_config_0_0.instance.invoke(context, Simplify.const3);
        if(term == null)
          break Fail918;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted6 extends Strategy 
  { 
    public static final lifted6 instance = new lifted6();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail919:
      { 
        if(term.getTermType() != IStrategoTerm.STRING || !"--test".equals(((IStrategoString)term).stringValue()))
          break Fail919;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted5 extends Strategy 
  { 
    public static final lifted5 instance = new lifted5();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail920:
      { 
        term = Simplify.const2;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted4 extends Strategy 
  { 
    public static final lifted4 instance = new lifted4();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail921:
      { 
        term = set_config_0_0.instance.invoke(context, Simplify.const1);
        if(term == null)
          break Fail921;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted3 extends Strategy 
  { 
    public static final lifted3 instance = new lifted3();

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail922:
      { 
        if(term.getTermType() != IStrategoTerm.STRING || !"--simple".equals(((IStrategoString)term).stringValue()))
          break Fail922;
        if(true)
          return term;
      }
      return null;
    }
  }

  @SuppressWarnings("all") private static final class lifted2 extends Strategy 
  { 
    Strategy c_25;

    @Override public IStrategoTerm invoke(Context context, IStrategoTerm term)
    { 
      Fail923:
      { 
        term = do_defaults_1_0.instance.invoke(context, term, c_25);
        if(term == null)
          break Fail923;
        if(true)
          return term;
      }
      return null;
    }
  }

  public static void registerInterop(org.spoofax.interpreter.core.IContext context, Context compiledContext)
  { 
    new InteropRegisterer().registerLazy(context, compiledContext, InteropRegisterer.class.getClassLoader());
  }

  @SuppressWarnings("unused") public static class InteropRegisterer extends org.strategoxt.lang.InteropRegisterer 
  { 
    @Override public void register(org.spoofax.interpreter.core.IContext context, Context compiledContext)
    { 
      register(context, compiledContext, context.getVarScope());
    }

    @Override public void registerLazy(org.spoofax.interpreter.core.IContext context, Context compiledContext, ClassLoader classLoader)
    { 
      registerLazy(context, compiledContext, classLoader, context.getVarScope());
    }

    private void register(org.spoofax.interpreter.core.IContext context, Context compiledContext, org.spoofax.interpreter.core.VarScope varScope)
    { 
      compiledContext.registerComponent("Simplify");
      Simplify.init(compiledContext);
      varScope.addSVar("get_option_0_1", new InteropSDefT(get_option_0_1.instance, context));
      varScope.addSVar("debug_options_0_0", new InteropSDefT(debug_options_0_0.instance, context));
      varScope.addSVar("options_io_wrap_1_0", new InteropSDefT(options_io_wrap_1_0.instance, context));
      varScope.addSVar("set_options_0_0", new InteropSDefT(set_options_0_0.instance, context));
      varScope.addSVar("do_defaults_1_0", new InteropSDefT(do_defaults_1_0.instance, context));
      varScope.addSVar("option_group_default_0_0", new InteropSDefT(option_group_default_0_0.instance, context));
      varScope.addSVar("option_group_default_last_0_0", new InteropSDefT(option_group_default_last_0_0.instance, context));
      varScope.addSVar("option_group_default_more_0_0", new InteropSDefT(option_group_default_more_0_0.instance, context));
      varScope.addSVar("mutually_exclusive_options_default_0_0", new InteropSDefT(mutually_exclusive_options_default_0_0.instance, context));
      varScope.addSVar("mutually_exclusive_options_default_last_0_0", new InteropSDefT(mutually_exclusive_options_default_last_0_0.instance, context));
      varScope.addSVar("mutually_exclusive_options_default_more_0_0", new InteropSDefT(mutually_exclusive_options_default_more_0_0.instance, context));
      varScope.addSVar("cancel_duplicates_0_1", new InteropSDefT(cancel_duplicates_0_1.instance, context));
      varScope.addSVar("beautify_0_0", new InteropSDefT(beautify_0_0.instance, context));
      varScope.addSVar("NegMulConst_0_0", new InteropSDefT($Neg$Mul$Const_0_0.instance, context));
      varScope.addSVar("SortNeg_0_0", new InteropSDefT($Sort$Neg_0_0.instance, context));
      varScope.addSVar("Beautify_0_0", new InteropSDefT($Beautify_0_0.instance, context));
      varScope.addSVar("NegMul_0_0", new InteropSDefT($Neg$Mul_0_0.instance, context));
      varScope.addSVar("RemoveMul1_0_0", new InteropSDefT($Remove$Mul1_0_0.instance, context));
      varScope.addSVar("debug_assertions_0_0", new InteropSDefT(debug_assertions_0_0.instance, context));
      varScope.addSVar("try_assertion_0_0", new InteropSDefT(try_assertion_0_0.instance, context));
      varScope.addSVar("define_assertion_0_1", new InteropSDefT(define_assertion_0_1.instance, context));
      varScope.addSVar("undefine_assertions_0_0", new InteropSDefT(undefine_assertions_0_0.instance, context));
      varScope.addSVar("get_vars_0_0", new InteropSDefT(get_vars_0_0.instance, context));
      varScope.addSVar("record_assertions_0_1", new InteropSDefT(record_assertions_0_1.instance, context));
      varScope.addSVar("employ_assertion_0_0", new InteropSDefT(employ_assertion_0_0.instance, context));
      varScope.addSVar("define_assertion_gt_0_0", new InteropSDefT(define_assertion_gt_0_0.instance, context));
      varScope.addSVar("define_assertion_geq_0_0", new InteropSDefT(define_assertion_geq_0_0.instance, context));
      varScope.addSVar("build_equality_assertion_geq_0_0", new InteropSDefT(build_equality_assertion_geq_0_0.instance, context));
      varScope.addSVar("define_assertion_leq_0_0", new InteropSDefT(define_assertion_leq_0_0.instance, context));
      varScope.addSVar("build_equality_assertion_leq_0_0", new InteropSDefT(build_equality_assertion_leq_0_0.instance, context));
      varScope.addSVar("define_assertion_lt_0_0", new InteropSDefT(define_assertion_lt_0_0.instance, context));
      varScope.addSVar("define_assertion_neq_0_0", new InteropSDefT(define_assertion_neq_0_0.instance, context));
      varScope.addSVar("define_assertion_equ_0_0", new InteropSDefT(define_assertion_equ_0_0.instance, context));
      varScope.addSVar("define_assertion_false_0_1", new InteropSDefT(define_assertion_false_0_1.instance, context));
      varScope.addSVar("define_assertion_true_0_1", new InteropSDefT(define_assertion_true_0_1.instance, context));
      varScope.addSVar("minstring_0_0", new InteropSDefT(minstring_0_0.instance, context));
      varScope.addSVar("maxstring_0_0", new InteropSDefT(maxstring_0_0.instance, context));
      varScope.addSVar("normalise_0_0", new InteropSDefT(normalise_0_0.instance, context));
      varScope.addSVar("canonical_0_0", new InteropSDefT(canonical_0_0.instance, context));
      varScope.addSVar("grouped_0_0", new InteropSDefT(grouped_0_0.instance, context));
      varScope.addSVar("z_483", new InteropSDefT(z_483.instance, context));
      varScope.addSVar("eliminate_mul_1_0_0", new InteropSDefT(eliminate_mul_1_0_0.instance, context));
      varScope.addSVar("first_mul_0_0", new InteropSDefT(first_mul_0_0.instance, context));
      varScope.addSVar("PushDownNot_0_0", new InteropSDefT($Push$Down$Not_0_0.instance, context));
      varScope.addSVar("Eliminate_0_0", new InteropSDefT($Eliminate_0_0.instance, context));
      varScope.addSVar("LeftGroup_0_0", new InteropSDefT($Left$Group_0_0.instance, context));
      varScope.addSVar("SortExpr_0_0", new InteropSDefT($Sort$Expr_0_0.instance, context));
      varScope.addSVar("NormaliseCompare_0_0", new InteropSDefT($Normalise$Compare_0_0.instance, context));
      varScope.addSVar("variable_name_reorder_0_0", new InteropSDefT(variable_name_reorder_0_0.instance, context));
      varScope.addSVar("SortTerms_0_0", new InteropSDefT($Sort$Terms_0_0.instance, context));
      varScope.addSVar("comparison_reorder_0_0", new InteropSDefT(comparison_reorder_0_0.instance, context));
      varScope.addSVar("comparison_reorder_code_0_0", new InteropSDefT(comparison_reorder_code_0_0.instance, context));
      varScope.addSVar("is_comparison_0_0", new InteropSDefT(is_comparison_0_0.instance, context));
      varScope.addSVar("SortCompare_0_0", new InteropSDefT($Sort$Compare_0_0.instance, context));
      varScope.addSVar("MergeCompare_0_0_fragment_0", new InteropSDefT($Merge$Compare_0_0_fragment_0.instance, context));
      varScope.addSVar("MergeCompare_0_0", new InteropSDefT($Merge$Compare_0_0.instance, context));
      varScope.addSVar("EvalExpr_0_0", new InteropSDefT($Eval$Expr_0_0.instance, context));
      varScope.addSVar("EvalNeg_0_0", new InteropSDefT($Eval$Neg_0_0.instance, context));
      varScope.addSVar("compare_1_0", new InteropSDefT(compare_1_0.instance, context));
      varScope.addSVar("EvalAdd0_0_0", new InteropSDefT($Eval$Add0_0_0.instance, context));
      varScope.addSVar("EvalKnownTrue_0_0", new InteropSDefT($Eval$Known$True_0_0.instance, context));
      varScope.addSVar("EvalKnownOther_0_0", new InteropSDefT($Eval$Known$Other_0_0.instance, context));
      varScope.addSVar("MulAbs_0_0", new InteropSDefT($Mul$Abs_0_0.instance, context));
      varScope.addSVar("SortMul_0_0", new InteropSDefT($Sort$Mul_0_0.instance, context));
      varScope.addSVar("CombineMul_0_0", new InteropSDefT($Combine$Mul_0_0.instance, context));
      varScope.addSVar("EliminateMul1_0_0", new InteropSDefT($Eliminate$Mul1_0_0.instance, context));
      varScope.addSVar("add_assertions_0_0", new InteropSDefT(add_assertions_0_0.instance, context));
      varScope.addSVar("remove_duplicate_assertions_0_0", new InteropSDefT(remove_duplicate_assertions_0_0.instance, context));
      varScope.addSVar("IfAssertion_0_0", new InteropSDefT($If$Assertion_0_0.instance, context));
      varScope.addSVar("ForAssertion_0_0", new InteropSDefT($For$Assertion_0_0.instance, context));
      varScope.addSVar("RemoveDuplicateAssertion_0_0", new InteropSDefT($Remove$Duplicate$Assertion_0_0.instance, context));
      varScope.addSVar("debug_simplify_0_0", new InteropSDefT(debug_simplify_0_0.instance, context));
      varScope.addSVar("io_Simplify_0_0", new InteropSDefT(io_$Simplify_0_0.instance, context));
      varScope.addSVar("simplify_0_0", new InteropSDefT(simplify_0_0.instance, context));
      varScope.addSVar("propagate_constant_0_0", new InteropSDefT(propagate_constant_0_0.instance, context));
      varScope.addSVar("propagate_constant_assign_0_0", new InteropSDefT(propagate_constant_assign_0_0.instance, context));
      varScope.addSVar("propagate_constant_assert_0_0", new InteropSDefT(propagate_constant_assert_0_0.instance, context));
      varScope.addSVar("propagate_constant_assertion_0_0", new InteropSDefT(propagate_constant_assertion_0_0.instance, context));
      varScope.addSVar("propagate_constant_assertion_and_0_0", new InteropSDefT(propagate_constant_assertion_and_0_0.instance, context));
      varScope.addSVar("propagate_constant_cassign_0_0", new InteropSDefT(propagate_constant_cassign_0_0.instance, context));
      varScope.addSVar("propagate_constant_if_0_0", new InteropSDefT(propagate_constant_if_0_0.instance, context));
      varScope.addSVar("propagate_constant_ifknown_0_0", new InteropSDefT(propagate_constant_ifknown_0_0.instance, context));
      varScope.addSVar("propagate_constant_while_0_0", new InteropSDefT(propagate_constant_while_0_0.instance, context));
      varScope.addSVar("propagate_constant_for_0_0", new InteropSDefT(propagate_constant_for_0_0.instance, context));
      varScope.addSVar("propagate_constant_cfor_0_0", new InteropSDefT(propagate_constant_cfor_0_0.instance, context));
      varScope.addSVar("propagate_constant_procedure_0_0", new InteropSDefT(propagate_constant_procedure_0_0.instance, context));
      varScope.addSVar("propagate_constant_declarations_0_0", new InteropSDefT(propagate_constant_declarations_0_0.instance, context));
      varScope.addSVar("is_value_0_0", new InteropSDefT(is_value_0_0.instance, context));
      varScope.addSVar("solve_ifknown_0_0", new InteropSDefT(solve_ifknown_0_0.instance, context));
      varScope.addSVar("EvalIf_0_0", new InteropSDefT($Eval$If_0_0.instance, context));
      varScope.addSVar("EvalWhile_0_0", new InteropSDefT($Eval$While_0_0.instance, context));
      varScope.addSVar("EvalFor_0_0", new InteropSDefT($Eval$For_0_0.instance, context));
      varScope.addSVar("EvalCFor_0_0", new InteropSDefT($Eval$C$For_0_0.instance, context));
      varScope.addSVar("EvalIfKnownTrue_0_0", new InteropSDefT($Eval$If$Known$True_0_0.instance, context));
      varScope.addSVar("EvalIfKnownOther_0_0", new InteropSDefT($Eval$If$Known$Other_0_0.instance, context));
      varScope.addSVar("main_0_0", new InteropSDefT(main_0_0.instance, context));
      varScope.addSVar("CFor_4_0", new InteropSDefT($C$For_4_0.instance, context));
      varScope.addSVar("Assert_1_0", new InteropSDefT($Assert_1_0.instance, context));
      varScope.addSVar("While_2_0", new InteropSDefT($While_2_0.instance, context));
      varScope.addSVar("For_4_0", new InteropSDefT($For_4_0.instance, context));
      varScope.addSVar("IfElse_3_0", new InteropSDefT($If$Else_3_0.instance, context));
      varScope.addSVar("If_2_0", new InteropSDefT($If_2_0.instance, context));
      varScope.addSVar("Assign_2_0", new InteropSDefT($Assign_2_0.instance, context));
      varScope.addSVar("Procedure_5_0", new InteropSDefT($Procedure_5_0.instance, context));
      varScope.addSVar("Var_1_0", new InteropSDefT($Var_1_0.instance, context));
      varScope.addSVar("CAssign_2_0", new InteropSDefT($C$Assign_2_0.instance, context));
      varScope.addSVar("IfElseExp_3_0", new InteropSDefT($If$Else$Exp_3_0.instance, context));
      varScope.addSVar("IfKnownExp_3_0", new InteropSDefT($If$Known$Exp_3_0.instance, context));
      varScope.addSVar("And_2_0", new InteropSDefT($And_2_0.instance, context));
      varScope.addSVar("Neq_2_0", new InteropSDefT($Neq_2_0.instance, context));
      varScope.addSVar("Equ_2_0", new InteropSDefT($Equ_2_0.instance, context));
      varScope.addSVar("Leq_2_0", new InteropSDefT($Leq_2_0.instance, context));
      varScope.addSVar("Gt_2_0", new InteropSDefT($Gt_2_0.instance, context));
      varScope.addSVar("Lt_2_0", new InteropSDefT($Lt_2_0.instance, context));
      varScope.addSVar("Int_1_0", new InteropSDefT($Int_1_0.instance, context));
      varScope.addSVar("Assertion7_0_0", new InteropSDefT($Assertion7_0_0.instance, context));
      varScope.addSVar("Assertion6_0_0", new InteropSDefT($Assertion6_0_0.instance, context));
      varScope.addSVar("Assertion5_0_0", new InteropSDefT($Assertion5_0_0.instance, context));
      varScope.addSVar("Assertion4_0_0", new InteropSDefT($Assertion4_0_0.instance, context));
      varScope.addSVar("Assertion3_0_0", new InteropSDefT($Assertion3_0_0.instance, context));
      varScope.addSVar("Assertion2_0_0", new InteropSDefT($Assertion2_0_0.instance, context));
      varScope.addSVar("Assertion1_0_0", new InteropSDefT($Assertion1_0_0.instance, context));
      varScope.addSVar("bagof_UsedInAssertion_0_0", new InteropSDefT(bagof_$Used$In$Assertion_0_0.instance, context));
      varScope.addSVar("aux_UsedInAssertion_0_2", new InteropSDefT(aux_$Used$In$Assertion_0_2.instance, context));
      varScope.addSVar("aux_Assertion3_0_3", new InteropSDefT(aux_$Assertion3_0_3.instance, context));
      varScope.addSVar("aux_Assertion4_0_3", new InteropSDefT(aux_$Assertion4_0_3.instance, context));
      varScope.addSVar("aux_Assertion1_0_3", new InteropSDefT(aux_$Assertion1_0_3.instance, context));
      varScope.addSVar("aux_Assertion2_0_3", new InteropSDefT(aux_$Assertion2_0_3.instance, context));
      varScope.addSVar("aux_Assertion5_0_3", new InteropSDefT(aux_$Assertion5_0_3.instance, context));
      varScope.addSVar("aux_Assertion7_0_2", new InteropSDefT(aux_$Assertion7_0_2.instance, context));
      varScope.addSVar("aux_Assertion6_0_3", new InteropSDefT(aux_$Assertion6_0_3.instance, context));
      varScope.addSVar("PropagateConstant_0_0", new InteropSDefT($Propagate$Constant_0_0.instance, context));
      varScope.addSVar("aux_PropagateConstant_0_2", new InteropSDefT(aux_$Propagate$Constant_0_2.instance, context));
    }

    private void registerLazy(org.spoofax.interpreter.core.IContext context, Context compiledContext, ClassLoader classLoader, org.spoofax.interpreter.core.VarScope varScope)
    { 
      compiledContext.registerComponent("Simplify");
      Simplify.init(compiledContext);
      varScope.addSVar("get_option_0_1", new InteropSDefT(classLoader, "Simplify$get_option_0_1", context));
      varScope.addSVar("debug_options_0_0", new InteropSDefT(classLoader, "Simplify$debug_options_0_0", context));
      varScope.addSVar("options_io_wrap_1_0", new InteropSDefT(classLoader, "Simplify$options_io_wrap_1_0", context));
      varScope.addSVar("set_options_0_0", new InteropSDefT(classLoader, "Simplify$set_options_0_0", context));
      varScope.addSVar("do_defaults_1_0", new InteropSDefT(classLoader, "Simplify$do_defaults_1_0", context));
      varScope.addSVar("option_group_default_0_0", new InteropSDefT(classLoader, "Simplify$option_group_default_0_0", context));
      varScope.addSVar("option_group_default_last_0_0", new InteropSDefT(classLoader, "Simplify$option_group_default_last_0_0", context));
      varScope.addSVar("option_group_default_more_0_0", new InteropSDefT(classLoader, "Simplify$option_group_default_more_0_0", context));
      varScope.addSVar("mutually_exclusive_options_default_0_0", new InteropSDefT(classLoader, "Simplify$mutually_exclusive_options_default_0_0", context));
      varScope.addSVar("mutually_exclusive_options_default_last_0_0", new InteropSDefT(classLoader, "Simplify$mutually_exclusive_options_default_last_0_0", context));
      varScope.addSVar("mutually_exclusive_options_default_more_0_0", new InteropSDefT(classLoader, "Simplify$mutually_exclusive_options_default_more_0_0", context));
      varScope.addSVar("cancel_duplicates_0_1", new InteropSDefT(classLoader, "Simplify$cancel_duplicates_0_1", context));
      varScope.addSVar("beautify_0_0", new InteropSDefT(classLoader, "Simplify$beautify_0_0", context));
      varScope.addSVar("NegMulConst_0_0", new InteropSDefT(classLoader, "Simplify$$Neg$Mul$Const_0_0", context));
      varScope.addSVar("SortNeg_0_0", new InteropSDefT(classLoader, "Simplify$$Sort$Neg_0_0", context));
      varScope.addSVar("Beautify_0_0", new InteropSDefT(classLoader, "Simplify$$Beautify_0_0", context));
      varScope.addSVar("NegMul_0_0", new InteropSDefT(classLoader, "Simplify$$Neg$Mul_0_0", context));
      varScope.addSVar("RemoveMul1_0_0", new InteropSDefT(classLoader, "Simplify$$Remove$Mul1_0_0", context));
      varScope.addSVar("debug_assertions_0_0", new InteropSDefT(classLoader, "Simplify$debug_assertions_0_0", context));
      varScope.addSVar("try_assertion_0_0", new InteropSDefT(classLoader, "Simplify$try_assertion_0_0", context));
      varScope.addSVar("define_assertion_0_1", new InteropSDefT(classLoader, "Simplify$define_assertion_0_1", context));
      varScope.addSVar("undefine_assertions_0_0", new InteropSDefT(classLoader, "Simplify$undefine_assertions_0_0", context));
      varScope.addSVar("get_vars_0_0", new InteropSDefT(classLoader, "Simplify$get_vars_0_0", context));
      varScope.addSVar("record_assertions_0_1", new InteropSDefT(classLoader, "Simplify$record_assertions_0_1", context));
      varScope.addSVar("employ_assertion_0_0", new InteropSDefT(classLoader, "Simplify$employ_assertion_0_0", context));
      varScope.addSVar("define_assertion_gt_0_0", new InteropSDefT(classLoader, "Simplify$define_assertion_gt_0_0", context));
      varScope.addSVar("define_assertion_geq_0_0", new InteropSDefT(classLoader, "Simplify$define_assertion_geq_0_0", context));
      varScope.addSVar("build_equality_assertion_geq_0_0", new InteropSDefT(classLoader, "Simplify$build_equality_assertion_geq_0_0", context));
      varScope.addSVar("define_assertion_leq_0_0", new InteropSDefT(classLoader, "Simplify$define_assertion_leq_0_0", context));
      varScope.addSVar("build_equality_assertion_leq_0_0", new InteropSDefT(classLoader, "Simplify$build_equality_assertion_leq_0_0", context));
      varScope.addSVar("define_assertion_lt_0_0", new InteropSDefT(classLoader, "Simplify$define_assertion_lt_0_0", context));
      varScope.addSVar("define_assertion_neq_0_0", new InteropSDefT(classLoader, "Simplify$define_assertion_neq_0_0", context));
      varScope.addSVar("define_assertion_equ_0_0", new InteropSDefT(classLoader, "Simplify$define_assertion_equ_0_0", context));
      varScope.addSVar("define_assertion_false_0_1", new InteropSDefT(classLoader, "Simplify$define_assertion_false_0_1", context));
      varScope.addSVar("define_assertion_true_0_1", new InteropSDefT(classLoader, "Simplify$define_assertion_true_0_1", context));
      varScope.addSVar("minstring_0_0", new InteropSDefT(classLoader, "Simplify$minstring_0_0", context));
      varScope.addSVar("maxstring_0_0", new InteropSDefT(classLoader, "Simplify$maxstring_0_0", context));
      varScope.addSVar("normalise_0_0", new InteropSDefT(classLoader, "Simplify$normalise_0_0", context));
      varScope.addSVar("canonical_0_0", new InteropSDefT(classLoader, "Simplify$canonical_0_0", context));
      varScope.addSVar("grouped_0_0", new InteropSDefT(classLoader, "Simplify$grouped_0_0", context));
      varScope.addSVar("z_483", new InteropSDefT(classLoader, "Simplify$z_483", context));
      varScope.addSVar("eliminate_mul_1_0_0", new InteropSDefT(classLoader, "Simplify$eliminate_mul_1_0_0", context));
      varScope.addSVar("first_mul_0_0", new InteropSDefT(classLoader, "Simplify$first_mul_0_0", context));
      varScope.addSVar("PushDownNot_0_0", new InteropSDefT(classLoader, "Simplify$$Push$Down$Not_0_0", context));
      varScope.addSVar("Eliminate_0_0", new InteropSDefT(classLoader, "Simplify$$Eliminate_0_0", context));
      varScope.addSVar("LeftGroup_0_0", new InteropSDefT(classLoader, "Simplify$$Left$Group_0_0", context));
      varScope.addSVar("SortExpr_0_0", new InteropSDefT(classLoader, "Simplify$$Sort$Expr_0_0", context));
      varScope.addSVar("NormaliseCompare_0_0", new InteropSDefT(classLoader, "Simplify$$Normalise$Compare_0_0", context));
      varScope.addSVar("variable_name_reorder_0_0", new InteropSDefT(classLoader, "Simplify$variable_name_reorder_0_0", context));
      varScope.addSVar("SortTerms_0_0", new InteropSDefT(classLoader, "Simplify$$Sort$Terms_0_0", context));
      varScope.addSVar("comparison_reorder_0_0", new InteropSDefT(classLoader, "Simplify$comparison_reorder_0_0", context));
      varScope.addSVar("comparison_reorder_code_0_0", new InteropSDefT(classLoader, "Simplify$comparison_reorder_code_0_0", context));
      varScope.addSVar("is_comparison_0_0", new InteropSDefT(classLoader, "Simplify$is_comparison_0_0", context));
      varScope.addSVar("SortCompare_0_0", new InteropSDefT(classLoader, "Simplify$$Sort$Compare_0_0", context));
      varScope.addSVar("MergeCompare_0_0_fragment_0", new InteropSDefT(classLoader, "Simplify$$Merge$Compare_0_0_fragment_0", context));
      varScope.addSVar("MergeCompare_0_0", new InteropSDefT(classLoader, "Simplify$$Merge$Compare_0_0", context));
      varScope.addSVar("EvalExpr_0_0", new InteropSDefT(classLoader, "Simplify$$Eval$Expr_0_0", context));
      varScope.addSVar("EvalNeg_0_0", new InteropSDefT(classLoader, "Simplify$$Eval$Neg_0_0", context));
      varScope.addSVar("compare_1_0", new InteropSDefT(classLoader, "Simplify$compare_1_0", context));
      varScope.addSVar("EvalAdd0_0_0", new InteropSDefT(classLoader, "Simplify$$Eval$Add0_0_0", context));
      varScope.addSVar("EvalKnownTrue_0_0", new InteropSDefT(classLoader, "Simplify$$Eval$Known$True_0_0", context));
      varScope.addSVar("EvalKnownOther_0_0", new InteropSDefT(classLoader, "Simplify$$Eval$Known$Other_0_0", context));
      varScope.addSVar("MulAbs_0_0", new InteropSDefT(classLoader, "Simplify$$Mul$Abs_0_0", context));
      varScope.addSVar("SortMul_0_0", new InteropSDefT(classLoader, "Simplify$$Sort$Mul_0_0", context));
      varScope.addSVar("CombineMul_0_0", new InteropSDefT(classLoader, "Simplify$$Combine$Mul_0_0", context));
      varScope.addSVar("EliminateMul1_0_0", new InteropSDefT(classLoader, "Simplify$$Eliminate$Mul1_0_0", context));
      varScope.addSVar("add_assertions_0_0", new InteropSDefT(classLoader, "Simplify$add_assertions_0_0", context));
      varScope.addSVar("remove_duplicate_assertions_0_0", new InteropSDefT(classLoader, "Simplify$remove_duplicate_assertions_0_0", context));
      varScope.addSVar("IfAssertion_0_0", new InteropSDefT(classLoader, "Simplify$$If$Assertion_0_0", context));
      varScope.addSVar("ForAssertion_0_0", new InteropSDefT(classLoader, "Simplify$$For$Assertion_0_0", context));
      varScope.addSVar("RemoveDuplicateAssertion_0_0", new InteropSDefT(classLoader, "Simplify$$Remove$Duplicate$Assertion_0_0", context));
      varScope.addSVar("debug_simplify_0_0", new InteropSDefT(classLoader, "Simplify$debug_simplify_0_0", context));
      varScope.addSVar("io_Simplify_0_0", new InteropSDefT(classLoader, "Simplify$io_$Simplify_0_0", context));
      varScope.addSVar("simplify_0_0", new InteropSDefT(classLoader, "Simplify$simplify_0_0", context));
      varScope.addSVar("propagate_constant_0_0", new InteropSDefT(classLoader, "Simplify$propagate_constant_0_0", context));
      varScope.addSVar("propagate_constant_assign_0_0", new InteropSDefT(classLoader, "Simplify$propagate_constant_assign_0_0", context));
      varScope.addSVar("propagate_constant_assert_0_0", new InteropSDefT(classLoader, "Simplify$propagate_constant_assert_0_0", context));
      varScope.addSVar("propagate_constant_assertion_0_0", new InteropSDefT(classLoader, "Simplify$propagate_constant_assertion_0_0", context));
      varScope.addSVar("propagate_constant_assertion_and_0_0", new InteropSDefT(classLoader, "Simplify$propagate_constant_assertion_and_0_0", context));
      varScope.addSVar("propagate_constant_cassign_0_0", new InteropSDefT(classLoader, "Simplify$propagate_constant_cassign_0_0", context));
      varScope.addSVar("propagate_constant_if_0_0", new InteropSDefT(classLoader, "Simplify$propagate_constant_if_0_0", context));
      varScope.addSVar("propagate_constant_ifknown_0_0", new InteropSDefT(classLoader, "Simplify$propagate_constant_ifknown_0_0", context));
      varScope.addSVar("propagate_constant_while_0_0", new InteropSDefT(classLoader, "Simplify$propagate_constant_while_0_0", context));
      varScope.addSVar("propagate_constant_for_0_0", new InteropSDefT(classLoader, "Simplify$propagate_constant_for_0_0", context));
      varScope.addSVar("propagate_constant_cfor_0_0", new InteropSDefT(classLoader, "Simplify$propagate_constant_cfor_0_0", context));
      varScope.addSVar("propagate_constant_procedure_0_0", new InteropSDefT(classLoader, "Simplify$propagate_constant_procedure_0_0", context));
      varScope.addSVar("propagate_constant_declarations_0_0", new InteropSDefT(classLoader, "Simplify$propagate_constant_declarations_0_0", context));
      varScope.addSVar("is_value_0_0", new InteropSDefT(classLoader, "Simplify$is_value_0_0", context));
      varScope.addSVar("solve_ifknown_0_0", new InteropSDefT(classLoader, "Simplify$solve_ifknown_0_0", context));
      varScope.addSVar("EvalIf_0_0", new InteropSDefT(classLoader, "Simplify$$Eval$If_0_0", context));
      varScope.addSVar("EvalWhile_0_0", new InteropSDefT(classLoader, "Simplify$$Eval$While_0_0", context));
      varScope.addSVar("EvalFor_0_0", new InteropSDefT(classLoader, "Simplify$$Eval$For_0_0", context));
      varScope.addSVar("EvalCFor_0_0", new InteropSDefT(classLoader, "Simplify$$Eval$C$For_0_0", context));
      varScope.addSVar("EvalIfKnownTrue_0_0", new InteropSDefT(classLoader, "Simplify$$Eval$If$Known$True_0_0", context));
      varScope.addSVar("EvalIfKnownOther_0_0", new InteropSDefT(classLoader, "Simplify$$Eval$If$Known$Other_0_0", context));
      varScope.addSVar("main_0_0", new InteropSDefT(classLoader, "Simplify$main_0_0", context));
      varScope.addSVar("CFor_4_0", new InteropSDefT(classLoader, "Simplify$$C$For_4_0", context));
      varScope.addSVar("Assert_1_0", new InteropSDefT(classLoader, "Simplify$$Assert_1_0", context));
      varScope.addSVar("While_2_0", new InteropSDefT(classLoader, "Simplify$$While_2_0", context));
      varScope.addSVar("For_4_0", new InteropSDefT(classLoader, "Simplify$$For_4_0", context));
      varScope.addSVar("IfElse_3_0", new InteropSDefT(classLoader, "Simplify$$If$Else_3_0", context));
      varScope.addSVar("If_2_0", new InteropSDefT(classLoader, "Simplify$$If_2_0", context));
      varScope.addSVar("Assign_2_0", new InteropSDefT(classLoader, "Simplify$$Assign_2_0", context));
      varScope.addSVar("Procedure_5_0", new InteropSDefT(classLoader, "Simplify$$Procedure_5_0", context));
      varScope.addSVar("Var_1_0", new InteropSDefT(classLoader, "Simplify$$Var_1_0", context));
      varScope.addSVar("CAssign_2_0", new InteropSDefT(classLoader, "Simplify$$C$Assign_2_0", context));
      varScope.addSVar("IfElseExp_3_0", new InteropSDefT(classLoader, "Simplify$$If$Else$Exp_3_0", context));
      varScope.addSVar("IfKnownExp_3_0", new InteropSDefT(classLoader, "Simplify$$If$Known$Exp_3_0", context));
      varScope.addSVar("And_2_0", new InteropSDefT(classLoader, "Simplify$$And_2_0", context));
      varScope.addSVar("Neq_2_0", new InteropSDefT(classLoader, "Simplify$$Neq_2_0", context));
      varScope.addSVar("Equ_2_0", new InteropSDefT(classLoader, "Simplify$$Equ_2_0", context));
      varScope.addSVar("Leq_2_0", new InteropSDefT(classLoader, "Simplify$$Leq_2_0", context));
      varScope.addSVar("Gt_2_0", new InteropSDefT(classLoader, "Simplify$$Gt_2_0", context));
      varScope.addSVar("Lt_2_0", new InteropSDefT(classLoader, "Simplify$$Lt_2_0", context));
      varScope.addSVar("Int_1_0", new InteropSDefT(classLoader, "Simplify$$Int_1_0", context));
      varScope.addSVar("Assertion7_0_0", new InteropSDefT(classLoader, "Simplify$$Assertion7_0_0", context));
      varScope.addSVar("Assertion6_0_0", new InteropSDefT(classLoader, "Simplify$$Assertion6_0_0", context));
      varScope.addSVar("Assertion5_0_0", new InteropSDefT(classLoader, "Simplify$$Assertion5_0_0", context));
      varScope.addSVar("Assertion4_0_0", new InteropSDefT(classLoader, "Simplify$$Assertion4_0_0", context));
      varScope.addSVar("Assertion3_0_0", new InteropSDefT(classLoader, "Simplify$$Assertion3_0_0", context));
      varScope.addSVar("Assertion2_0_0", new InteropSDefT(classLoader, "Simplify$$Assertion2_0_0", context));
      varScope.addSVar("Assertion1_0_0", new InteropSDefT(classLoader, "Simplify$$Assertion1_0_0", context));
      varScope.addSVar("bagof_UsedInAssertion_0_0", new InteropSDefT(classLoader, "Simplify$bagof_$Used$In$Assertion_0_0", context));
      varScope.addSVar("aux_UsedInAssertion_0_2", new InteropSDefT(classLoader, "Simplify$aux_$Used$In$Assertion_0_2", context));
      varScope.addSVar("aux_Assertion3_0_3", new InteropSDefT(classLoader, "Simplify$aux_$Assertion3_0_3", context));
      varScope.addSVar("aux_Assertion4_0_3", new InteropSDefT(classLoader, "Simplify$aux_$Assertion4_0_3", context));
      varScope.addSVar("aux_Assertion1_0_3", new InteropSDefT(classLoader, "Simplify$aux_$Assertion1_0_3", context));
      varScope.addSVar("aux_Assertion2_0_3", new InteropSDefT(classLoader, "Simplify$aux_$Assertion2_0_3", context));
      varScope.addSVar("aux_Assertion5_0_3", new InteropSDefT(classLoader, "Simplify$aux_$Assertion5_0_3", context));
      varScope.addSVar("aux_Assertion7_0_2", new InteropSDefT(classLoader, "Simplify$aux_$Assertion7_0_2", context));
      varScope.addSVar("aux_Assertion6_0_3", new InteropSDefT(classLoader, "Simplify$aux_$Assertion6_0_3", context));
      varScope.addSVar("PropagateConstant_0_0", new InteropSDefT(classLoader, "Simplify$$Propagate$Constant_0_0", context));
      varScope.addSVar("aux_PropagateConstant_0_2", new InteropSDefT(classLoader, "Simplify$aux_$Propagate$Constant_0_2", context));
    }
  }
}